home *** CD-ROM | disk | FTP | other *** search
/ The Java 3D API Specification (2nd Edition) / The Java 3D API Specification (2nd Edition).iso / programs / examples / FourByFour / Board.java < prev    next >
Text File  |  2000-04-28  |  90KB  |  2,297 lines
  1. /*
  2.  *    @(#)Board.java 1.6 00/02/10 13:13:47
  3.  *
  4.  * Copyright (c) 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  *
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  *
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  30.  
  31. import java.awt.*;
  32.  
  33. /**
  34.  *  Class:       Board
  35.  *
  36.  *  Description: Handles all logic with respect to play. Also renders
  37.  *               the 2D window.
  38.  *
  39.  *  Version:     1.1
  40.  *
  41.  */
  42. class Board {
  43.  
  44.    final static int UNOCCUPIED = 0;
  45.    final static int HUMAN      = 1;
  46.    final static int MACHINE    = 2;
  47.    final static int END        = 3;
  48.  
  49.    private int[]      moves;
  50.    private int[]      occupied;
  51.    private int[][]    combinations;
  52.    private int[][]    outside_four;
  53.    private int[][]    inside_four;
  54.    private int[][]    faces;
  55.    private int[][]    pos_to_comb;
  56.    private int[][]    best_picks;
  57.    private int        num_points;
  58.    private int        num_balls;
  59.    private int        num_polygons;
  60.    private int        num_pt_indexes;
  61.    private int        num_normal_indexes;
  62.    private int        pt_start;
  63.    private int        color_index;
  64.    private int        width;
  65.    private int        height;
  66.    private int        center_x;
  67.    private int        center_y;
  68.    private int        player;
  69.    private int        skill_level;
  70.    private int        outside_four_index;
  71.    private int        inside_four_index;
  72.    private int        face_index;
  73.    private int        nmoves;
  74.    private int        current_face;
  75.    private int        min = 1000;
  76.    private int        max = 0;
  77.    private long[]     sort_array;
  78.    private long       time;
  79.    private long       beg_time;
  80.    private long       end_time;
  81.    private Color[]    color_ramp;
  82.    private Color      background;
  83.    private Color      label_color;
  84.    private Color      red;
  85.    private Color      blue;
  86.    private Color      white;
  87.    private Color      gray;
  88.    private Color      yellow;
  89.    private double     max_dist;
  90.    private FourByFour panel;
  91.    private boolean    debug;
  92.    private boolean    outside_four_flag;
  93.    private boolean    inside_four_flag;
  94.    private boolean    face_flag;
  95.    private boolean    label_flag;
  96.    private boolean    block_chair_flag;
  97.    private boolean    undoFlag;
  98.    private boolean[]  highlight;
  99.    private int        block_chair_next_move;
  100.    private int        block_chair_face;
  101.    private Positions  positions;
  102.    private Canvas2D   canvas;
  103.  
  104.    Board (FourByFour panel, Positions positions, int width, int height) {
  105.  
  106.       // Set the debug state.
  107.       debug = false;
  108.  
  109.       // Store arguments
  110.       this.width = width;
  111.       this.height = height;
  112.       this.panel = panel;
  113.       this.positions = positions;
  114.  
  115.       // Initialize flags
  116.       label_flag = false;
  117.       outside_four_flag = false;
  118.       inside_four_flag = false;
  119.       block_chair_flag = false;
  120.       undoFlag = false;
  121.  
  122.       // Total number of board positions.
  123.       num_points = 64;
  124.  
  125.       // Allocate the logic arrays.
  126.       moves = new int[64];
  127.       occupied = new int[64];
  128.       combinations = new int[76][7];
  129.       outside_four = new int[18][6];
  130.       inside_four = new int[18][6];
  131.       faces = new int[18][18];
  132.       pos_to_comb = new int[64][8];
  133.       best_picks = new int[64][8];
  134.       highlight = new boolean[18];
  135.  
  136.       // Initialize the logic arrays.
  137.       init_combinations();
  138.       init_faces();
  139.       init_outside_four();
  140.       init_inside_four();
  141.  
  142.       // Set the player with the first move. 
  143.       player = HUMAN;
  144.  
  145.       // Set the default skill level.
  146.       skill_level = 4;
  147.  
  148.       // Initialize the number of moves.
  149.       nmoves = 0;
  150.  
  151.       // Define colors
  152.       background = new Color(13, 13, 51);
  153.       red = new Color(230, 26, 51);
  154.       blue = new Color(51, 51, 230);
  155.       white = new Color(255, 255, 255);
  156.       gray = new Color(240, 240, 240);
  157.       yellow = new Color(240, 240, 0);
  158.  
  159.       // Record the start time
  160.       beg_time = System.currentTimeMillis();
  161.    }
  162.  
  163.    public void setCanvas(Canvas2D canvas) {
  164.       this.canvas = canvas;
  165.    }
  166.  
  167.    public void init_combinations () {
  168.  
  169.       // The combination array contains all possible winning combinations.
  170.       //
  171.       // Each combination has the following format:
  172.       //
  173.       // combinations[x][0] =  status: 0      = no player has selected positons in this row
  174.       //                              -1      = both players have men in this row
  175.       //                               1 to 4 = number of positions occupied by player
  176.       //
  177.       // combinations[x][1] =  player who owns this row (valid only if status = 1-4)
  178.       // combinations[x][2] =  postion that define the row 
  179.       // combinations[x][3] =  postion that define the row 
  180.       // combinations[x][4] =  postion that define the row 
  181.       // combinations[x][5] =  postion that define the row 
  182.  
  183.       // Horizontal, Z
  184.  
  185.       combinations[ 0][0] =  0;  combinations[ 1][0] =  0;  combinations[ 2][0] =  0;  combinations[ 3][0] =  0;
  186.       combinations[ 0][1] =  0;  combinations[ 1][1] =  0;  combinations[ 2][1] =  0;  combinations[ 3][1] =  0;
  187.       combinations[ 0][2] =  0;  combinations[ 1][2] =  4;  combinations[ 2][2] =  8;  combinations[ 3][2] = 12;
  188.       combinations[ 0][3] =  1;  combinations[ 1][3] =  5;  combinations[ 2][3] =  9;  combinations[ 3][3] = 13;
  189.       combinations[ 0][4] =  2;  combinations[ 1][4] =  6;  combinations[ 2][4] = 10;  combinations[ 3][4] = 14;
  190.       combinations[ 0][5] =  3;  combinations[ 1][5] =  7;  combinations[ 2][5] = 11;  combinations[ 3][5] = 15;
  191.  
  192.       combinations[ 4][0] =  0;  combinations[ 5][0] =  0;  combinations[ 6][0] =  0;  combinations[ 7][0] =  0;
  193.       combinations[ 4][1] =  0;  combinations[ 5][1] =  0;  combinations[ 6][1] =  0;  combinations[ 7][1] =  0;
  194.       combinations[ 4][2] = 16;  combinations[ 5][2] = 20;  combinations[ 6][2] = 24;  combinations[ 7][2] = 28;
  195.       combinations[ 4][3] = 17;  combinations[ 5][3] = 21;  combinations[ 6][3] = 25;  combinations[ 7][3] = 29;
  196.       combinations[ 4][4] = 18;  combinations[ 5][4] = 22;  combinations[ 6][4] = 26;  combinations[ 7][4] = 30;
  197.       combinations[ 4][5] = 19;  combinations[ 5][5] = 23;  combinations[ 6][5] = 27;  combinations[ 7][5] = 31;
  198.  
  199.       combinations[ 8][0] =  0;  combinations[ 9][0] =  0;  combinations[10][0] =  0;  combinations[11][0] =  0;
  200.       combinations[ 8][1] =  0;  combinations[ 9][1] =  0;  combinations[10][1] =  0;  combinations[11][1] =  0;
  201.       combinations[ 8][2] = 32;  combinations[ 9][2] = 36;  combinations[10][2] = 40;  combinations[11][2] = 44;
  202.       combinations[ 8][3] = 33;  combinations[ 9][3] = 37;  combinations[10][3] = 41;  combinations[11][3] = 45;
  203.       combinations[ 8][4] = 34;  combinations[ 9][4] = 38;  combinations[10][4] = 42;  combinations[11][4] = 46;
  204.       combinations[ 8][5] = 35;  combinations[ 9][5] = 39;  combinations[10][5] = 43;  combinations[11][5] = 47;
  205.  
  206.       combinations[12][0] =  0;  combinations[13][0] =  0;  combinations[14][0] =  0;  combinations[15][0] =  0;
  207.       combinations[12][1] =  0;  combinations[13][1] =  0;  combinations[14][1] =  0;  combinations[15][1] =  0;
  208.       combinations[12][2] = 48;  combinations[13][2] = 52;  combinations[14][2] = 56;  combinations[15][2] = 60;
  209.       combinations[12][3] = 49;  combinations[13][3] = 53;  combinations[14][3] = 57;  combinations[15][3] = 61;
  210.       combinations[12][4] = 50;  combinations[13][4] = 54;  combinations[14][4] = 58;  combinations[15][4] = 62;
  211.       combinations[12][5] = 51;  combinations[13][5] = 55;  combinations[14][5] = 59;  combinations[15][5] = 63;
  212.  
  213.       // Vertical, Z
  214.  
  215.       combinations[16][0] =  0;  combinations[17][0] =  0;  combinations[18][0] =  0;  combinations[19][0] =  0;
  216.       combinations[16][1] =  0;  combinations[17][1] =  0;  combinations[18][1] =  0;  combinations[19][1] =  0;
  217.       combinations[16][2] =  0;  combinations[17][2] =  1;  combinations[18][2] =  2;  combinations[19][2] =  3;
  218.       combinations[16][3] =  4;  combinations[17][3] =  5;  combinations[18][3] =  6;  combinations[19][3] =  7;
  219.       combinations[16][4] =  8;  combinations[17][4] =  9;  combinations[18][4] = 10;  combinations[19][4] = 11;
  220.       combinations[16][5] = 12;  combinations[17][5] = 13;  combinations[18][5] = 14;  combinations[19][5] = 15;
  221.  
  222.       combinations[20][0] =  0;  combinations[21][0] =  0;  combinations[22][0] =  0;  combinations[23][0] =  0;
  223.       combinations[20][1] =  0;  combinations[21][1] =  0;  combinations[22][1] =  0;  combinations[23][1] =  0;
  224.       combinations[20][2] = 16;  combinations[21][2] = 17;  combinations[22][2] = 18;  combinations[23][2] = 19;
  225.       combinations[20][3] = 20;  combinations[21][3] = 21;  combinations[22][3] = 22;  combinations[23][3] = 23;
  226.       combinations[20][4] = 24;  combinations[21][4] = 25;  combinations[22][4] = 26;  combinations[23][4] = 27;
  227.       combinations[20][5] = 28;  combinations[21][5] = 29;  combinations[22][5] = 30;  combinations[23][5] = 31;
  228.  
  229.       combinations[24][0] =  0;  combinations[25][0] =  0;  combinations[26][0] =  0;  combinations[27][0] =  0;
  230.       combinations[24][1] =  0;  combinations[25][1] =  0;  combinations[26][1] =  0;  combinations[27][1] =  0;
  231.       combinations[24][2] = 32;  combinations[25][2] = 33;  combinations[26][2] = 34;  combinations[27][2] = 35;
  232.       combinations[24][3] = 36;  combinations[25][3] = 37;  combinations[26][3] = 38;  combinations[27][3] = 39;
  233.       combinations[24][4] = 40;  combinations[25][4] = 41;  combinations[26][4] = 42;  combinations[27][4] = 43;
  234.       combinations[24][5] = 44;  combinations[25][5] = 45;  combinations[26][5] = 46;  combinations[27][5] = 47;
  235.  
  236.       combinations[28][0] =  0;  combinations[29][0] =  0;  combinations[30][0] =  0;  combinations[31][0] =  0;
  237.       combinations[28][1] =  0;  combinations[29][1] =  0;  combinations[30][1] =  0;  combinations[31][1] =  0;
  238.       combinations[28][2] = 48;  combinations[29][2] = 49;  combinations[30][2] = 50;  combinations[31][2] = 51;
  239.       combinations[28][3] = 52;  combinations[29][3] = 53;  combinations[30][3] = 54;  combinations[31][3] = 55;
  240.       combinations[28][4] = 56;  combinations[29][4] = 57;  combinations[30][4] = 58;  combinations[31][4] = 59;
  241.       combinations[28][5] = 60;  combinations[29][5] = 61;  combinations[30][5] = 62;  combinations[31][5] = 63;
  242.  
  243.       // Diagonal, Z
  244.  
  245.       combinations[32][0] =  0;  combinations[33][0] =  0;  combinations[34][0] =  0;  combinations[35][0] =  0;
  246.       combinations[32][1] =  0;  combinations[33][1] =  0;  combinations[34][1] =  0;  combinations[35][1] =  0;
  247.       combinations[32][2] =  0;  combinations[33][2] = 16;  combinations[34][2] = 32;  combinations[35][2] = 48;
  248.       combinations[32][3] =  5;  combinations[33][3] = 21;  combinations[34][3] = 37;  combinations[35][3] = 53;
  249.       combinations[32][4] = 10;  combinations[33][4] = 26;  combinations[34][4] = 42;  combinations[35][4] = 58;
  250.       combinations[32][5] = 15;  combinations[33][5] = 31;  combinations[34][5] = 47;  combinations[35][5] = 63;
  251.  
  252.       combinations[36][0] =  0;  combinations[37][0] =  0;  combinations[38][0] =  0;  combinations[39][0] =  0;
  253.       combinations[36][1] =  0;  combinations[37][1] =  0;  combinations[38][1] =  0;  combinations[39][1] =  0;
  254.       combinations[36][2] =  3;  combinations[37][2] = 19;  combinations[38][2] = 35;  combinations[39][2] = 51;
  255.       combinations[36][3] =  6;  combinations[37][3] = 22;  combinations[38][3] = 38;  combinations[39][3] = 54;
  256.       combinations[36][4] =  9;  combinations[37][4] = 25;  combinations[38][4] = 41;  combinations[39][4] = 57;
  257.       combinations[36][5] = 12;  combinations[37][5] = 28;  combinations[38][5] = 44;  combinations[39][5] = 60;
  258.  
  259.       // Horizontal, X
  260.  
  261.       combinations[40][0] =  0;  combinations[41][0] =  0;  combinations[42][0] =  0;  combinations[43][0] =  0;
  262.       combinations[40][1] =  0;  combinations[41][1] =  0;  combinations[42][1] =  0;  combinations[43][1] =  0;
  263.       combinations[40][2] = 51;  combinations[41][2] = 55;  combinations[42][2] = 59;  combinations[43][2] = 63;
  264.       combinations[40][3] = 35;  combinations[41][3] = 39;  combinations[42][3] = 43;  combinations[43][3] = 47;
  265.       combinations[40][4] = 19;  combinations[41][4] = 23;  combinations[42][4] = 27;  combinations[43][4] = 31;
  266.       combinations[40][5] =  3;  combinations[41][5] =  7;  combinations[42][5] = 11;  combinations[43][5] = 15;
  267.  
  268.       combinations[44][0] =  0;  combinations[45][0] =  0;  combinations[46][0] =  0;  combinations[47][0] =  0;
  269.       combinations[44][1] =  0;  combinations[45][1] =  0;  combinations[46][1] =  0;  combinations[47][1] =  0;
  270.       combinations[44][2] = 50;  combinations[45][2] = 54;  combinations[46][2] = 58;  combinations[47][2] = 62;
  271.       combinations[44][3] = 34;  combinations[45][3] = 38;  combinations[46][3] = 42;  combinations[47][3] = 46;
  272.       combinations[44][4] = 18;  combinations[45][4] = 22;  combinations[46][4] = 26;  combinations[47][4] = 30;
  273.       combinations[44][5] =  2;  combinations[45][5] =  6;  combinations[46][5] = 10;  combinations[47][5] = 14;
  274.  
  275.       combinations[48][0] =  0;  combinations[49][0] =  0;  combinations[50][0] =  0;  combinations[51][0] =  0;
  276.       combinations[48][1] =  0;  combinations[49][1] =  0;  combinations[50][1] =  0;  combinations[51][1] =  0;
  277.       combinations[48][2] = 49;  combinations[49][2] = 53;  combinations[50][2] = 57;  combinations[51][2] = 61;
  278.       combinations[48][3] = 33;  combinations[49][3] = 37;  combinations[50][3] = 41;  combinations[51][3] = 45;
  279.       combinations[48][4] = 17;  combinations[49][4] = 21;  combinations[50][4] = 25;  combinations[51][4] = 29;
  280.       combinations[48][5] =  1;  combinations[49][5] =  5;  combinations[50][5] =  9;  combinations[51][5] = 13;
  281.  
  282.       combinations[52][0] =  0;  combinations[53][0] =  0;  combinations[54][0] =  0;  combinations[55][0] =  0;
  283.       combinations[52][1] =  0;  combinations[53][1] =  0;  combinations[54][1] =  0;  combinations[55][1] =  0;
  284.       combinations[52][2] = 48;  combinations[53][2] = 52;  combinations[54][2] = 56;  combinations[55][2] = 60;
  285.       combinations[52][3] = 32;  combinations[53][3] = 36;  combinations[54][3] = 40;  combinations[55][3] = 44;
  286.       combinations[52][4] = 16;  combinations[53][4] = 20;  combinations[54][4] = 24;  combinations[55][4] = 28;
  287.       combinations[52][5] =  0;  combinations[53][5] =  4;  combinations[54][5] =  8;  combinations[55][5] = 12;
  288.  
  289.       // Diagonal, X
  290.  
  291.       combinations[56][0] =  0;  combinations[57][0] =  0;  combinations[58][0] =  0;  combinations[59][0] =  0;
  292.       combinations[56][1] =  0;  combinations[57][1] =  0;  combinations[58][1] =  0;  combinations[59][1] =  0;
  293.       combinations[56][2] = 51;  combinations[57][2] = 50;  combinations[58][2] = 49;  combinations[59][2] = 48;
  294.       combinations[56][3] = 39;  combinations[57][3] = 38;  combinations[58][3] = 37;  combinations[59][3] = 36;
  295.       combinations[56][4] = 27;  combinations[57][4] = 26;  combinations[58][4] = 25;  combinations[59][4] = 24;
  296.       combinations[56][5] = 15;  combinations[57][5] = 14;  combinations[58][5] = 13;  combinations[59][5] = 12;
  297.  
  298.       combinations[60][0] =  0;  combinations[61][0] =  0;  combinations[62][0] =  0;  combinations[63][0] =  0;
  299.       combinations[60][1] =  0;  combinations[61][1] =  0;  combinations[62][1] =  0;  combinations[63][1] =  0;
  300.       combinations[60][2] =  3;  combinations[61][2] =  2;  combinations[62][2] =  1;  combinations[63][2] =  0;
  301.       combinations[60][3] = 23;  combinations[61][3] = 22;  combinations[62][3] = 21;  combinations[63][3] = 20;
  302.       combinations[60][4] = 43;  combinations[61][4] = 42;  combinations[62][4] = 41;  combinations[63][4] = 40;
  303.       combinations[60][5] = 63;  combinations[61][5] = 62;  combinations[62][5] = 61;  combinations[63][5] = 60;
  304.  
  305.       // Diagonal, Y
  306.  
  307.       combinations[64][0] =  0;  combinations[65][0] =  0;  combinations[66][0] =  0;  combinations[67][0] =  0;
  308.       combinations[64][1] =  0;  combinations[65][1] =  0;  combinations[66][1] =  0;  combinations[67][1] =  0;
  309.       combinations[64][2] = 63;  combinations[65][2] = 59;  combinations[66][2] = 55;  combinations[67][2] = 51;
  310.       combinations[64][3] = 46;  combinations[65][3] = 42;  combinations[66][3] = 38;  combinations[67][3] = 34;
  311.       combinations[64][4] = 29;  combinations[65][4] = 25;  combinations[66][4] = 21;  combinations[67][4] = 17;
  312.       combinations[64][5] = 12;  combinations[65][5] =  8;  combinations[66][5] =  4;  combinations[67][5] =  0;
  313.  
  314.       combinations[68][0] =  0;  combinations[69][0] =  0;  combinations[70][0] =  0;  combinations[71][0] =  0;
  315.       combinations[68][1] =  0;  combinations[69][1] =  0;  combinations[70][1] =  0;  combinations[71][1] =  0;
  316.       combinations[68][2] = 15;  combinations[69][2] = 11;  combinations[70][2] =  7;  combinations[71][2] =  3;
  317.       combinations[68][3] = 30;  combinations[69][3] = 26;  combinations[70][3] = 22;  combinations[71][3] = 18;
  318.       combinations[68][4] = 45;  combinations[69][4] = 41;  combinations[70][4] = 37;  combinations[71][4] = 33;
  319.       combinations[68][5] = 60;  combinations[69][5] = 56;  combinations[70][5] = 52;  combinations[71][5] = 48;
  320.  
  321.       // Corner to Corner
  322.  
  323.       combinations[72][0] =  0;  combinations[73][0] =  0;  combinations[74][0] =  0;  combinations[75][0] =  0;
  324.       combinations[72][1] =  0;  combinations[73][1] =  0;  combinations[74][1] =  0;  combinations[75][1] =  0;
  325.       combinations[72][2] =  0;  combinations[73][2] =  3;  combinations[74][2] = 12;  combinations[75][2] = 15;
  326.       combinations[72][3] = 21;  combinations[73][3] = 22;  combinations[74][3] = 25;  combinations[75][3] = 26;
  327.       combinations[72][4] = 42;  combinations[73][4] = 41;  combinations[74][4] = 38;  combinations[75][4] = 37;
  328.       combinations[72][5] = 63;  combinations[73][5] = 60;  combinations[74][5] = 51;  combinations[75][5] = 48;
  329.  
  330.       // Initialize the combination flags to zero.
  331.       for (int i=0; i<76; i++) 
  332.          combinations[i][6] = 0;
  333.  
  334.       // Set up the pos_to_comb array to point to every winning combination that a given 
  335.       // position may have.
  336.       setup_pos_to_comb();
  337.  
  338.       // Set up the best_picks array.
  339.       update_best_picks();
  340.    }
  341.  
  342.  
  343.   /**
  344.    *  Initialize the "outside four" array. 
  345.    */
  346.    public void init_outside_four() {
  347.       for (int i=0; i<18; i++) {
  348.          outside_four[i][0] = 0;
  349.          outside_four[i][1] = 0;
  350.          outside_four[i][2] = faces[i][ 2];
  351.          outside_four[i][3] = faces[i][ 5];
  352.          outside_four[i][4] = faces[i][14];
  353.          outside_four[i][5] = faces[i][17];
  354.       }
  355.    }
  356.  
  357.  
  358.   /**
  359.    *  Initialize the "inside four" array.
  360.    */
  361.    public void init_inside_four() {
  362.       for (int i=0; i<18; i++) {
  363.          inside_four[i][0] = 0;
  364.          inside_four[i][1] = 0;
  365.          inside_four[i][2] = faces[i][ 7];
  366.          inside_four[i][3] = faces[i][ 8];
  367.          inside_four[i][4] = faces[i][11];
  368.          inside_four[i][5] = faces[i][12];
  369.       }
  370.    }
  371.  
  372.   /**
  373.    *  Initialize the "faces" array. 
  374.    */
  375.    public void init_faces () {
  376.  
  377.       faces[ 0][ 0] =  0;
  378.       faces[ 0][ 1] =  0;
  379.       faces[ 0][ 2] = 12;  faces[ 0][ 6] = 13;  faces[ 0][10] = 14;  faces[ 0][14] = 15;
  380.       faces[ 0][ 3] =  8;  faces[ 0][ 7] =  9;  faces[ 0][11] = 10;  faces[ 0][15] = 11;
  381.       faces[ 0][ 4] =  4;  faces[ 0][ 8] =  5;  faces[ 0][12] =  6;  faces[ 0][16] =  7;
  382.       faces[ 0][ 5] =  0;  faces[ 0][ 9] =  1;  faces[ 0][13] =  2;  faces[ 0][17] =  3;
  383.  
  384.       faces[ 1][ 0] =  0;
  385.       faces[ 1][ 1] =  0;
  386.       faces[ 1][ 2] = 28;  faces[ 1][ 6] = 29;  faces[ 1][10] = 30;  faces[ 1][14] = 31;
  387.       faces[ 1][ 3] = 24;  faces[ 1][ 7] = 25;  faces[ 1][11] = 26;  faces[ 1][15] = 27;
  388.       faces[ 1][ 4] = 20;  faces[ 1][ 8] = 21;  faces[ 1][12] = 22;  faces[ 1][16] = 23;
  389.       faces[ 1][ 5] = 16;  faces[ 1][ 9] = 17;  faces[ 1][13] = 18;  faces[ 1][17] = 19;
  390.  
  391.       faces[ 2][ 0] =  0;
  392.       faces[ 2][ 1] =  0;
  393.       faces[ 2][ 2] = 44;  faces[ 2][ 6] = 45;  faces[ 2][10] = 46;  faces[ 2][14] = 47;
  394.       faces[ 2][ 3] = 40;  faces[ 2][ 7] = 41;  faces[ 2][11] = 42;  faces[ 2][15] = 43;
  395.       faces[ 2][ 4] = 36;  faces[ 2][ 8] = 37;  faces[ 2][12] = 38;  faces[ 2][16] = 39;
  396.       faces[ 2][ 5] = 32;  faces[ 2][ 9] = 33;  faces[ 2][13] = 34;  faces[ 2][17] = 35;
  397.  
  398.       faces[ 3][ 0] =  0;
  399.       faces[ 3][ 1] =  0;
  400.       faces[ 3][ 2] = 60;  faces[ 3][ 6] = 61;  faces[ 3][10] = 62;  faces[ 3][14] = 63;
  401.       faces[ 3][ 3] = 56;  faces[ 3][ 7] = 57;  faces[ 3][11] = 58;  faces[ 3][15] = 59;
  402.       faces[ 3][ 4] = 52;  faces[ 3][ 8] = 53;  faces[ 3][12] = 54;  faces[ 3][16] = 55;
  403.       faces[ 3][ 5] = 48;  faces[ 3][ 9] = 49;  faces[ 3][13] = 50;  faces[ 3][17] = 51;
  404.  
  405.       faces[ 4][ 0] =  0;
  406.       faces[ 4][ 1] =  0;
  407.       faces[ 4][ 2] = 12;  faces[ 4][ 6] = 28;  faces[ 4][10] = 44;  faces[ 4][14] = 60;
  408.       faces[ 4][ 3] =  8;  faces[ 4][ 7] = 24;  faces[ 4][11] = 40;  faces[ 4][15] = 56;
  409.       faces[ 4][ 4] =  4;  faces[ 4][ 8] = 20;  faces[ 4][12] = 36;  faces[ 4][16] = 52;
  410.       faces[ 4][ 5] =  0;  faces[ 4][ 9] = 16;  faces[ 4][13] = 32;  faces[ 4][17] = 48;
  411.  
  412.       faces[ 5][ 0] =  0;
  413.       faces[ 5][ 1] =  0;
  414.       faces[ 5][ 2] = 13;  faces[ 5][ 6] = 29;  faces[ 5][10] = 45;  faces[ 5][14] = 61;
  415.       faces[ 5][ 3] =  9;  faces[ 5][ 7] = 25;  faces[ 5][11] = 41;  faces[ 5][15] = 57;
  416.       faces[ 5][ 4] =  5;  faces[ 5][ 8] = 21;  faces[ 5][12] = 37;  faces[ 5][16] = 53;
  417.       faces[ 5][ 5] =  1;  faces[ 5][ 9] = 17;  faces[ 5][13] = 33;  faces[ 5][17] = 49;
  418.  
  419.       faces[ 6][ 0] =  0;
  420.       faces[ 6][ 1] =  0;
  421.       faces[ 6][ 2] = 14;  faces[ 6][ 6] = 30;  faces[ 6][10] = 46;  faces[ 6][14] = 62;
  422.       faces[ 6][ 3] = 10;  faces[ 6][ 7] = 26;  faces[ 6][11] = 42;  faces[ 6][15] = 58;
  423.       faces[ 6][ 4] =  6;  faces[ 6][ 8] = 22;  faces[ 6][12] = 38;  faces[ 6][16] = 54;
  424.       faces[ 6][ 5] =  2;  faces[ 6][ 9] = 18;  faces[ 6][13] = 34;  faces[ 6][17] = 50;
  425.  
  426.       faces[ 7][ 0] =  0;
  427.       faces[ 7][ 1] =  0;
  428.       faces[ 7][ 2] = 15;  faces[ 7][ 6] = 31;  faces[ 7][10] = 47;  faces[ 7][14] = 63;
  429.       faces[ 7][ 3] = 11;  faces[ 7][ 7] = 27;  faces[ 7][11] = 43;  faces[ 7][15] = 59;
  430.       faces[ 7][ 4] =  7;  faces[ 7][ 8] = 23;  faces[ 7][12] = 39;  faces[ 7][16] = 55;
  431.       faces[ 7][ 5] =  3;  faces[ 7][ 9] = 19;  faces[ 7][13] = 35;  faces[ 7][17] = 51;
  432.  
  433.       faces[ 8][ 0] =  0;
  434.       faces[ 8][ 1] =  0;
  435.       faces[ 8][ 2] = 12;  faces[ 8][ 6] = 28;  faces[ 8][10] = 44;  faces[ 8][14] = 60;
  436.       faces[ 8][ 3] = 13;  faces[ 8][ 7] = 29;  faces[ 8][11] = 45;  faces[ 8][15] = 61;
  437.       faces[ 8][ 4] = 14;  faces[ 8][ 8] = 30;  faces[ 8][12] = 46;  faces[ 8][16] = 62;
  438.       faces[ 8][ 5] = 15;  faces[ 8][ 9] = 31;  faces[ 8][13] = 47;  faces[ 8][17] = 63;
  439.  
  440.       faces[ 9][ 0] =  0;
  441.       faces[ 9][ 1] =  0;
  442.       faces[ 9][ 2] =  8;  faces[ 9][ 6] = 24;  faces[ 9][10] = 40;  faces[ 9][14] = 56;
  443.       faces[ 9][ 3] =  9;  faces[ 9][ 7] = 25;  faces[ 9][11] = 41;  faces[ 9][15] = 57;
  444.       faces[ 9][ 4] = 10;  faces[ 9][ 8] = 26;  faces[ 9][12] = 42;  faces[ 9][16] = 58;
  445.       faces[ 9][ 5] = 11;  faces[ 9][ 9] = 27;  faces[ 9][13] = 43;  faces[ 9][17] = 59;
  446.  
  447.       faces[10][ 0] =  0;
  448.       faces[10][ 1] =  0;
  449.       faces[10][ 2] =  4;  faces[10][ 6] = 20;  faces[10][10] = 36;  faces[10][14] = 52;
  450.       faces[10][ 3] =  5;  faces[10][ 7] = 21;  faces[10][11] = 37;  faces[10][15] = 53;
  451.       faces[10][ 4] =  6;  faces[10][ 8] = 22;  faces[10][12] = 38;  faces[10][16] = 54;
  452.       faces[10][ 5] =  7;  faces[10][ 9] = 23;  faces[10][13] = 39;  faces[10][17] = 55;
  453.  
  454.       faces[11][ 0] =  0;
  455.       faces[11][ 1] =  0;
  456.       faces[11][ 2] =  0;  faces[11][ 6] = 16;  faces[11][10] = 32;  faces[11][14] = 48;
  457.       faces[11][ 3] =  1;  faces[11][ 7] = 17;  faces[11][11] = 33;  faces[11][15] = 49;
  458.       faces[11][ 4] =  2;  faces[11][ 8] = 18;  faces[11][12] = 34;  faces[11][16] = 50;
  459.       faces[11][ 5] =  3;  faces[11][ 9] = 19;  faces[11][13] = 35;  faces[11][17] = 51;
  460.  
  461.       faces[12][ 0] =  0;
  462.       faces[12][ 1] =  0;
  463.       faces[12][ 2] = 12;  faces[12][ 6] = 13;  faces[12][10] = 14;  faces[12][14] = 15;
  464.       faces[12][ 3] = 24;  faces[12][ 7] = 25;  faces[12][11] = 26;  faces[12][15] = 27;
  465.       faces[12][ 4] = 36;  faces[12][ 8] = 37;  faces[12][12] = 38;  faces[12][16] = 39;
  466.       faces[12][ 5] = 48;  faces[12][ 9] = 49;  faces[12][13] = 50;  faces[12][17] = 51;
  467.  
  468.       faces[13][ 0] =  0;
  469.       faces[13][ 1] =  0;
  470.       faces[13][ 2] =  0;  faces[13][ 6] =  1;  faces[13][10] =  2;  faces[13][14] =  3;
  471.       faces[13][ 3] = 20;  faces[13][ 7] = 21;  faces[13][11] = 22;  faces[13][15] = 23;
  472.       faces[13][ 4] = 40;  faces[13][ 8] = 41;  faces[13][12] = 42;  faces[13][16] = 43;
  473.       faces[13][ 5] = 60;  faces[13][ 9] = 61;  faces[13][13] = 62;  faces[13][17] = 63;
  474.  
  475.       faces[14][ 0] =  0;
  476.       faces[14][ 1] =  0;
  477.       faces[14][ 2] = 12;  faces[14][ 6] = 28;  faces[14][10] = 44;  faces[14][14] = 60;
  478.       faces[14][ 3] =  9;  faces[14][ 7] = 25;  faces[14][11] = 41;  faces[14][15] = 57;
  479.       faces[14][ 4] =  6;  faces[14][ 8] = 22;  faces[14][12] = 38;  faces[14][16] = 54;
  480.       faces[14][ 5] =  3;  faces[14][ 9] = 19;  faces[14][13] = 35;  faces[14][17] = 51;
  481.  
  482.       faces[15][ 0] =  0;
  483.       faces[15][ 1] =  0;
  484.       faces[15][ 2] = 15;  faces[15][ 6] = 31;  faces[15][10] = 47;  faces[15][14] = 63;
  485.       faces[15][ 3] = 10;  faces[15][ 7] = 26;  faces[15][11] = 42;  faces[15][15] = 58;
  486.       faces[15][ 4] =  5;  faces[15][ 8] = 21;  faces[15][12] = 37;  faces[15][16] = 53;
  487.       faces[15][ 5] =  0;  faces[15][ 9] = 16;  faces[15][13] = 32;  faces[15][17] = 48;
  488.  
  489.       faces[16][ 0] =  0;
  490.       faces[16][ 1] =  0;
  491.       faces[16][ 2] = 12;  faces[16][ 6] = 29;  faces[16][10] = 46;  faces[16][14] = 63;
  492.       faces[16][ 3] =  8;  faces[16][ 7] = 25;  faces[16][11] = 42;  faces[16][15] = 59;
  493.       faces[16][ 4] =  4;  faces[16][ 8] = 21;  faces[16][12] = 38;  faces[16][16] = 55;
  494.       faces[16][ 5] =  0;  faces[16][ 9] = 17;  faces[16][13] = 34;  faces[16][17] = 51;
  495.  
  496.       faces[17][ 0] =  0;
  497.       faces[17][ 1] =  0;
  498.       faces[17][ 2] = 15;  faces[17][ 6] = 30;  faces[17][10] = 45;  faces[17][14] = 60;
  499.       faces[17][ 3] = 11;  faces[17][ 7] = 26;  faces[17][11] = 41;  faces[17][15] = 56;
  500.       faces[17][ 4] =  7;  faces[17][ 8] = 22;  faces[17][12] = 37;  faces[17][16] = 52;
  501.       faces[17][ 5] =  3;  faces[17][ 9] = 18;  faces[17][13] = 33;  faces[17][17] = 48;
  502.    }
  503.  
  504.    /**
  505.     *  Render the current face set in the 2D window.
  506.     */
  507.    public void render2D(Graphics gc) {
  508.  
  509.       gc.setColor(background);
  510.       gc.fillRect(0, 0, width, height);
  511.  
  512.       int id;
  513.       int x, y;
  514.  
  515.       float begX;
  516.       float begY;
  517.  
  518.       for (int l=0; l<3; l++) {
  519.          begY =  28.0f + l*(5.f*23.3f);
  520.          for (int k=0; k<6; k++) {
  521.             begX =  11.65f + k*(5.f*11.65f);
  522.             int count = 0;
  523.             int face = l*6+k;
  524.             for (int i=0; i<4; i++) {
  525.                for (int j=0; j<4; j++) {
  526.                   x = (int)begX + i*12;
  527.                   y = (int)begY + j*12;
  528.                   id = faces[face][count+2];
  529.                   if (occupied[id] == HUMAN) {
  530.                      x -= 2;
  531.                      y -= 2;
  532.                      gc.setColor(red);
  533.                      gc.fillRect(x, y, 5, 5);
  534.                   }
  535.                   else if (occupied[id] == MACHINE) {
  536.                      x -= 2;
  537.                      y -= 2;
  538.                      gc.setColor(blue);
  539.                      gc.fillRect(x, y, 5, 5);
  540.                   }
  541.                   else {
  542.                      x -= 1;
  543.                      y -= 1;
  544.                      gc.setColor(gray);
  545.                      gc.fillRect(x, y, 2, 2);
  546.                   }
  547.                   if (highlight[face]) {
  548.                      gc.setColor(yellow);
  549.                      positions.setHighlight(faces[face][count+2]);
  550.                   }
  551.                   count++;
  552.                }
  553.             }
  554.             if (highlight[face])
  555.                gc.setColor(yellow);
  556.             else
  557.                gc.setColor(white);
  558.             if ((face+1)<10)
  559.                gc.drawString("Face "+(face+1), (int)begX-2, (int)begY+60);
  560.             else
  561.                gc.drawString("Face "+(face+1), (int)begX-4, (int)begY+60);
  562.          }
  563.       }
  564.    }
  565.  
  566.    /**
  567.     *  Determine what position has been selected in the 2D window.
  568.     */
  569.    public void checkSelection2D(int x, int y, int player) {
  570.  
  571.       int id;
  572.       int posX, posY;
  573.  
  574.       float begX;
  575.       float begY;
  576.  
  577.       for (int l=0; l<3; l++) {
  578.          begY =  28.0f + l*(5.f*23.3f);
  579.          for (int k=0; k<6; k++) {
  580.             begX =  11.65f + k*(5.f*11.65f);
  581.             int count = 0;
  582.             int face = l*6+k;
  583.             for (int i=0; i<4; i++) {
  584.                for (int j=0; j<4; j++) {
  585.                   posX = (int)begX + i*12;
  586.                   posY = (int)begY + j*12;
  587.                   if (x > posX-4 && x < posX+4 &&
  588.                       y > posY-4 && y < posY+4) {
  589.  
  590.                      id = faces[face][count+2];
  591.  
  592.                      if (occupied[id] == UNOCCUPIED) {
  593.                         positions.set(id, player);
  594.                         selection(id, player);
  595.                         canvas.repaint();
  596.                      }
  597.                      return;
  598.                   }
  599.                   count++;
  600.                }
  601.             }
  602.             if ((x > begX-4  && x < begX+40) && 
  603.                 (y > begY+45 && y < begY+60)   ) {
  604.  
  605.                count = 0;
  606.                for (int i=0; i<4; i++) {
  607.                   for (int j=0; j<4; j++) {
  608.                      if (highlight[face])
  609.                         positions.clearHighlight(faces[face][count+2]);
  610.                      count++;
  611.                   }
  612.                }
  613.                if (highlight[face])
  614.                   highlight[face] = false;
  615.                else
  616.                   highlight[face] = true;
  617.                canvas.repaint();
  618.             }
  619.          }
  620.       }
  621.  
  622.    }
  623.  
  624.  
  625.    /**
  626.     *  Record the player's move.
  627.     */
  628.    public void selection(int pos, int player) {
  629.  
  630.       int num_combinations;
  631.       int comb;
  632.  
  633.       this.player = player;
  634.  
  635.       if (player == HUMAN) {
  636.  
  637.          // If position is already occupied, return.
  638.          if (occupied[pos] != 0) return;
  639.  
  640.          // Mark the position as HUMAN.
  641.          occupied[pos] = HUMAN;
  642.  
  643.          // Update the logic arrays.
  644.          this.player = update_logic_arrays(pos);
  645.  
  646.          // Have the computer determine its move.
  647.          choose_move();
  648.       }
  649.    }
  650.  
  651.  
  652.    /**
  653.     *  Determine the computer's move.
  654.     */
  655.    public void choose_move () {
  656.       
  657.       if (player == MACHINE) {
  658.  
  659.          // Babe in the woods.
  660.          if (skill_level == 0) {
  661.             if (!block_winning_move()) {
  662.                if (!pick_7()) {
  663.                   if (!check_outside_four()) {
  664.                      pick_best_position();
  665.                   }
  666.                }
  667.             }
  668.          }
  669.  
  670.          // Walk and chew gum.
  671.          else if (skill_level == 1) {
  672.             if (!block_winning_move()) {
  673.                if (!block_intersecting_rows()) {
  674.                   if (!block_inside_four()) {
  675.                      if (!block_outside_four()) {
  676.                            pick_best_position();
  677.                      }
  678.                   }
  679.                }
  680.             }
  681.          }
  682.  
  683.          // Jeopordy contestant.
  684.          else if (skill_level == 2) {
  685.             if (!block_winning_move()) {
  686.                if (!block_intersecting_rows()) {
  687.                   if (!block_inside_four()) {
  688.                      if (!block_outside_four()) {
  689.                         if (!pick_7()) {
  690.                            pick_best_position();
  691.                         }
  692.                      }
  693.                   }
  694.                }
  695.             }
  696.          }
  697.  
  698.          // Rocket scientist.
  699.          else if (skill_level == 3) {
  700.             if (!block_winning_move()) {
  701.                if (!block_intersecting_rows()) {
  702.                   if (!block_chair_move()) {
  703.                      if (!check_face_three()) {
  704.                         if (!block_central_four()) {
  705.                            if (!block_inside_four()) {
  706.                               if (!block_outside_four()) {
  707.                                  if (!take_inside_four()) {
  708.                                     if (!take_outside_four()) {
  709.                                        if (!pick_7()) {
  710.                                           if (!check_outside_four()) {
  711.                                              pick_best_position();
  712.                                           }
  713.                                        }
  714.                                     }
  715.                                  }
  716.                               }
  717.                            }
  718.                         }
  719.                      }
  720.                   }
  721.                }
  722.             }
  723.          }
  724.  
  725.          // Be afraid, be very afraid.
  726.          else if (skill_level == 4) {
  727.             if (!block_winning_move()) {
  728.                if (!block_intersecting_rows()) {
  729.                   if (!block_chair_move()) {
  730.                      if (!block_walk_move()) {
  731.                         if (!block_central_four()) {
  732.                            if (!block_inside_four()) {
  733.                               if (!block_outside_four()) {
  734.                                  if (!check_face_three()) {
  735.                                     if (!check_intersecting_rows2()) {
  736.                                        if (!take_inside_four()) {
  737.                                           if (!take_outside_four()) {
  738.                                              if (!pick_7()) {
  739.                                                 if (!check_outside_four()) {
  740.                                                    pick_best_position();
  741.                                                 }
  742.                                              }
  743.                                           }
  744.                                        }
  745.                                     }
  746.                                  }
  747.                               }
  748.                            }
  749.                         }
  750.                      }
  751.                   }
  752.                }
  753.             }
  754.          }
  755.       }
  756.    }
  757.  
  758.  
  759.    /**
  760.     *  Check for a winning move.
  761.     */
  762.    public boolean block_winning_move() {
  763.  
  764.       // Loop through each combination and see if any player occupies 
  765.       // three positions. If so, take the last remaining position.
  766.       int pos;
  767.       for (int i=0; i<76; i++) {
  768.          if (combinations[i][0] == 3) {
  769.             for (int j=2; j<6; j++) {
  770.                pos = combinations[i][j];
  771.                if (occupied[pos] == 0) {
  772.                   occupied[pos] = MACHINE;
  773.                   positions.set(pos, MACHINE);
  774.                   player = update_logic_arrays(pos);
  775.                   if (debug) System.out.println("block_winning_move:  true");
  776.                   return true;  
  777.                }
  778.             }
  779.          }
  780.       }
  781.       if (debug) System.out.println("check_winning_move:  false");
  782.       return false;
  783.    }
  784.  
  785.  
  786.    /**
  787.     *  Block outside four
  788.     */
  789.    public boolean block_outside_four() {
  790.  
  791.       int pos;
  792.       int index = 0;
  793.       int max = 0;
  794.  
  795.       // Block the opponent, if necessary.
  796.       for (int i=0; i<18; i++) {
  797.          if (outside_four[i][0] > 0 &&
  798.              outside_four[i][1] == HUMAN) {
  799.             if(outside_four[i][0] > max) {
  800.                index = i;
  801.                max = outside_four[i][0];
  802.             }
  803.          }
  804.       }
  805.  
  806.       if (max > 0) {
  807.          for (int j=2; j<6; j++) {
  808.             pos = outside_four[index][j];
  809.             if (occupied[pos] == 0) {
  810.                occupied[pos] = MACHINE;
  811.                positions.set(pos, MACHINE);
  812.                player = update_logic_arrays(pos);
  813.                if (debug) System.out.println("block_outside_four:  true");
  814.                return true;
  815.             }
  816.          }
  817.       }
  818.  
  819.       if (debug) System.out.println("block_outside_four:  false");
  820.       return false;
  821.    }
  822.  
  823.  
  824.    /**
  825.     *  Block central four
  826.     */
  827.    public boolean block_central_four() {
  828.  
  829.       int pos;   
  830.       int index = 0;
  831.       int max = 0;
  832.  
  833.       // Block the opponent, if necessary.
  834.       for (int i=1; i<3; i++) {
  835.          if (inside_four[i][0] > 0 &&
  836.              inside_four[i][1] == HUMAN) {
  837.             if(inside_four[i][0] > max) {
  838.                index = i;
  839.                max = inside_four[i][0];
  840.             }
  841.          }
  842.       }   
  843.  
  844.       if (max > 0) {
  845.          for (int j=2; j<6; j++) {
  846.             pos = inside_four[index][j];
  847.             if (occupied[pos] == 0) {
  848.                occupied[pos] = MACHINE;
  849.                positions.set(pos, MACHINE);
  850.                player = update_logic_arrays(pos);
  851.                if (debug) System.out.println("block_central_four:  true");
  852.                return true;
  853.             }
  854.          }
  855.       }   
  856.  
  857.       if (debug) System.out.println("block_central_four:  false");
  858.       return false;
  859.    }
  860.  
  861.    /**   
  862.     *  Check each face for a forced win.
  863.     */   
  864.    public boolean check_face_three() {
  865.      
  866.       int pos;   
  867.       int index = 0;
  868.       int human = 0;
  869.       int machine = 0;
  870.  
  871.       // Block the opponent from a forced win.
  872.       for (int i=0; i<18; i++) {
  873.          if (outside_four[i][0] == -1) {
  874.             human = 0;
  875.             machine = 0;
  876.             for (int j=2; j<6; j++) {
  877.                if (occupied[outside_four[i][j]] == MACHINE)
  878.                   machine++;
  879.                else if (occupied[outside_four[i][j]] == HUMAN)
  880.                   human++;
  881.             }
  882.             if (debug) System.out.println("machine = " + machine);
  883.             if (debug) System.out.println("human   = " + human);
  884.             if (human == 3 && machine == 1) {
  885.                if (debug) System.out.println("human == 3 && machine == 1");
  886.                for (int j=2; j<18; j++) {
  887.                   pos  = faces[i][j];
  888.                   if (occupied[pos] == 0) { 
  889.                      for (int k=0; k<76; k++) {
  890.                         if (combinations[i][0] == 2 &
  891.                             combinations[i][1] == HUMAN) {
  892.                            for (int l=0; l<4; l++) {
  893.                               if (combinations[i][l] == pos) {
  894.                                  occupied[pos] = MACHINE;
  895.                                  positions.set(pos, MACHINE);
  896.                                  player = update_logic_arrays(pos);
  897.                                  if (debug) System.out.println("check_face_three:  true");
  898.                                  return true;
  899.                               }
  900.                            }
  901.                         }
  902.                      }
  903.                   }
  904.                }
  905.             }
  906.          }
  907.       }     
  908.          
  909.       if (debug) System.out.println("check_face_three:  false");
  910.       return false;
  911.    }
  912.  
  913.  
  914.  
  915.    /**
  916.     *  Block inside four
  917.     */
  918.    public boolean block_inside_four() {
  919.  
  920.       int pos;
  921.       int index = 0;
  922.       int max = 0;
  923.  
  924.       // Block the opponent, if necessary.
  925.       for (int i=0; i<18; i++) {
  926.          if (inside_four[i][0] > 0 &&
  927.              inside_four[i][1] == HUMAN) {
  928.             if(inside_four[i][0] > max) {
  929.                index = i;
  930.                max = inside_four[i][0];
  931.             }
  932.          }
  933.       }   
  934.  
  935.       if (max > 0) {
  936.          for (int j=2; j<6; j++) {
  937.             pos = inside_four[index][j];
  938.             if (occupied[pos] == 0) {
  939.                occupied[pos] = MACHINE;
  940.                positions.set(pos, MACHINE);
  941.                player = update_logic_arrays(pos);
  942.                if (debug) System.out.println("block_inside_four:  true");
  943.                return true;
  944.             }
  945.          }
  946.       }   
  947.  
  948.       if (debug) System.out.println("block_inside_four:  false");
  949.       return false;
  950.    }
  951.  
  952.  
  953.    public boolean block_chair_move() {
  954.  
  955.       int pos;
  956.  
  957.       int ncorners = 0;    // Number of corners owned by human
  958.       int corner   = 0;    // Corner owned by machine
  959.  
  960.       if (debug) System.out.println("inside block_chair_move");
  961.  
  962.       // Loop through all of the faces.
  963.       for(int i=0; i<18; i++) {
  964.  
  965.          // Determine which corners the human owns.
  966.          if (occupied[faces[i][2]] == HUMAN)
  967.             ncorners++;   
  968.          else if (occupied[faces[i][2]] == MACHINE)
  969.             corner = 2;
  970.          if (occupied[faces[i][5]] == HUMAN) 
  971.             ncorners++;   
  972.          else if (occupied[faces[i][5]] == MACHINE)
  973.             corner = 5;
  974.          if (occupied[faces[i][14]] == HUMAN)
  975.             ncorners++;   
  976.          else if (occupied[faces[i][14]] == MACHINE)
  977.             corner = 14;
  978.          if (occupied[faces[i][17]] == HUMAN)
  979.             ncorners++;   
  980.          else if (occupied[faces[i][17]] == MACHINE)
  981.             corner = 17;
  982.  
  983.          // If the human owns three corners, continue with the search.
  984.          if (ncorners == 3) {
  985.             if (corner == 2) {
  986.                if (occupied[faces[i][ 3]] == HUMAN && occupied[faces[i][ 7]] == 0 &&
  987.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][11]] == 0 &&
  988.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  989.                   pos = faces[i][11];
  990.                   occupied[pos] = MACHINE;
  991.                   positions.set(pos, MACHINE);
  992.                   player = update_logic_arrays(pos);
  993.                   if (debug) System.out.println("block_chair_move: found");
  994.                   return true;
  995.                }
  996.                if (occupied[faces[i][ 4]] == HUMAN && occupied[faces[i][ 8]] == 0 &&
  997.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0 &&
  998.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  999.                   pos = faces[i][12];
  1000.                   occupied[pos] = MACHINE;
  1001.                   positions.set(pos, MACHINE);
  1002.                   player = update_logic_arrays(pos);
  1003.                   if (debug) System.out.println("block_chair_move: found");
  1004.                   return true;
  1005.                }
  1006.                if (occupied[faces[i][ 6]] == HUMAN && occupied[faces[i][ 7]] == 0 &&
  1007.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][ 9]] == 0 &&
  1008.                    occupied[faces[i][11]] == 0     && occupied[faces[i][13]] == 0) {
  1009.                   pos = faces[i][8];
  1010.                   occupied[pos] = MACHINE;
  1011.                   positions.set(pos, MACHINE);
  1012.                   player = update_logic_arrays(pos);
  1013.                   if (debug) System.out.println("block_chair_move: found");
  1014.                   return true;
  1015.                }
  1016.                if (occupied[faces[i][10]] == HUMAN && occupied[faces[i][ 8]] == 0 &&
  1017.                    occupied[faces[i][ 9]] == 0     && occupied[faces[i][11]] == 0 &&
  1018.                    occupied[faces[i][12]] == 0     && occupied[faces[i][13]] == 0) {
  1019.                   pos = faces[i][11];
  1020.                   occupied[pos] = MACHINE;
  1021.                   positions.set(pos, MACHINE);
  1022.                   player = update_logic_arrays(pos);
  1023.                   if (debug) System.out.println("block_chair_move: found");
  1024.                   return true;
  1025.                }
  1026.                if (occupied[faces[i][ 7]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1027.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][11]] == 0 &&
  1028.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1029.                   pos = faces[i][11];
  1030.                   occupied[pos] = MACHINE;
  1031.                   positions.set(pos, MACHINE);
  1032.                   player = update_logic_arrays(pos);
  1033.                   if (debug) System.out.println("block_chair_move: found");
  1034.                   return true;
  1035.                }
  1036.                if (occupied[faces[i][12]] == HUMAN && occupied[faces[i][ 4]] == 0 &&
  1037.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][11]] == 0 &&
  1038.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1039.                   pos = faces[i][16];
  1040.                   occupied[pos] = MACHINE;
  1041.                   positions.set(pos, MACHINE);
  1042.                   player = update_logic_arrays(pos);
  1043.                   if (debug) System.out.println("block_chair_move: found");
  1044.                   return true;
  1045.                }
  1046.             }
  1047.             else if (corner == 5) {
  1048.                if (occupied[faces[i][ 9]] == HUMAN && occupied[faces[i][ 6]] == 0 &&
  1049.                    occupied[faces[i][ 7]] == 0     && occupied[faces[i][ 8]] == 0 &&
  1050.                    occupied[faces[i][10]] == 0     && occupied[faces[i][12]] == 0) {
  1051.                   pos = faces[i][7];
  1052.                   occupied[pos] = MACHINE;
  1053.                   positions.set(pos, MACHINE);
  1054.                   player = update_logic_arrays(pos);
  1055.                   if (debug) System.out.println("block_chair_move: found");
  1056.                   return true;
  1057.                }
  1058.                if (occupied[faces[i][13]] == HUMAN && occupied[faces[i][ 7]] == 0 &&
  1059.                    occupied[faces[i][ 7]] == 0     && occupied[faces[i][10]] == 0 &&
  1060.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0) {
  1061.                   pos = faces[i][12];
  1062.                   occupied[pos] = MACHINE;
  1063.                   positions.set(pos, MACHINE);
  1064.                   player = update_logic_arrays(pos);
  1065.                   if (debug) System.out.println("block_chair_move: found");
  1066.                   return true;
  1067.                }
  1068.                if (occupied[faces[i][ 4]] == HUMAN && occupied[faces[i][ 8]] == 0 &&
  1069.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0 &&
  1070.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1071.                   pos = faces[i][12];
  1072.                   occupied[pos] = MACHINE;
  1073.                   positions.set(pos, MACHINE);
  1074.                   player = update_logic_arrays(pos);
  1075.                   if (debug) System.out.println("block_chair_move: found");
  1076.                   return true;
  1077.                }
  1078.                if (occupied[faces[i][ 3]] == HUMAN && occupied[faces[i][ 7]] == 0 &&
  1079.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0 &&
  1080.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1081.                   pos = faces[i][7];
  1082.                   occupied[pos] = MACHINE;
  1083.                   positions.set(pos, MACHINE);
  1084.                   player = update_logic_arrays(pos);
  1085.                   if (debug) System.out.println("block_chair_move: found");
  1086.                   return true;
  1087.                }
  1088.                if (occupied[faces[i][ 8]] == HUMAN && occupied[faces[i][ 4]] == 0 &&
  1089.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0 &&
  1090.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1091.                   pos = faces[i][12];
  1092.                   occupied[pos] = MACHINE;
  1093.                   positions.set(pos, MACHINE);
  1094.                   player = update_logic_arrays(pos);
  1095.                   if (debug) System.out.println("block_chair_move: found");
  1096.                   return true;
  1097.                }
  1098.                if (occupied[faces[i][11]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1099.                    occupied[faces[i][ 7]] == 0     && occupied[faces[i][12]] == 0 &&
  1100.                    occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0) {
  1101.                   pos = faces[i][ 7];
  1102.                   occupied[pos] = MACHINE;
  1103.                   positions.set(pos, MACHINE);
  1104.                   player = update_logic_arrays(pos);
  1105.                   if (debug) System.out.println("block_chair_move: found");
  1106.                   return true;
  1107.                }
  1108.             }
  1109.             else if (corner == 14) {
  1110.                if (occupied[faces[i][ 6]] == HUMAN && occupied[faces[i][ 7]] == 0 &&
  1111.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][ 9]] == 0 &&
  1112.                    occupied[faces[i][11]] == 0     && occupied[faces[i][13]] == 0) {
  1113.                   pos = faces[i][7];
  1114.                   occupied[pos] = MACHINE;
  1115.                   positions.set(pos, MACHINE);
  1116.                   player = update_logic_arrays(pos);
  1117.                   if (debug) System.out.println("block_chair_move: found");
  1118.                   return true;
  1119.                }
  1120.                if (occupied[faces[i][10]] == HUMAN && occupied[faces[i][ 8]] == 0 &&
  1121.                    occupied[faces[i][ 9]] == 0     && occupied[faces[i][11]] == 0 &&
  1122.                    occupied[faces[i][12]] == 0     && occupied[faces[i][13]] == 0) {
  1123.                   pos = faces[i][12];
  1124.                   occupied[pos] = MACHINE;
  1125.                   positions.set(pos, MACHINE);
  1126.                   player = update_logic_arrays(pos);
  1127.                   if (debug) System.out.println("block_chair_move: found");
  1128.                   return true;
  1129.                }
  1130.                if (occupied[faces[i][15]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1131.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 7]] == 0 &&
  1132.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0) {
  1133.                   pos = faces[i][3];
  1134.                   occupied[pos] = MACHINE;
  1135.                   positions.set(pos, MACHINE);
  1136.                   player = update_logic_arrays(pos);
  1137.                   if (debug) System.out.println("block_chair_move: found");
  1138.                   return true;
  1139.                }
  1140.                if (occupied[faces[i][16]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1141.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 7]] == 0 &&
  1142.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][12]] == 0) {
  1143.                   pos = faces[i][12];
  1144.                   occupied[pos] = MACHINE;
  1145.                   positions.set(pos, MACHINE);
  1146.                   player = update_logic_arrays(pos);
  1147.                   if (debug) System.out.println("block_chair_move: found");
  1148.                   return true;
  1149.                }
  1150.                if (occupied[faces[i][11]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1151.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 7]] == 0 &&
  1152.                    occupied[faces[i][12]] == 0     && occupied[faces[i][15]] == 0) {
  1153.                   pos = faces[i][7];
  1154.                   occupied[pos] = MACHINE;
  1155.                   positions.set(pos, MACHINE);
  1156.                   player = update_logic_arrays(pos);
  1157.                   if (debug) System.out.println("block_chair_move: found");
  1158.                   return true;
  1159.                }
  1160.                if (occupied[faces[i][ 8]] == HUMAN && occupied[faces[i][ 6]] == 0 &&
  1161.                    occupied[faces[i][ 7]] == 0     && occupied[faces[i][ 9]] == 0 &&
  1162.                    occupied[faces[i][12]] == 0     && occupied[faces[i][13]] == 0) {
  1163.                   pos = faces[i][7];
  1164.                   occupied[pos] = MACHINE;
  1165.                   positions.set(pos, MACHINE);
  1166.                   player = update_logic_arrays(pos);
  1167.                   if (debug) System.out.println("block_chair_move: found");
  1168.                   return true;
  1169.                }
  1170.             }
  1171.             else if (corner == 17) {
  1172.                if (occupied[faces[i][ 9]] == HUMAN && occupied[faces[i][ 6]] == 0 &&
  1173.                    occupied[faces[i][ 7]] == 0     && occupied[faces[i][ 8]] == 0 &&
  1174.                    occupied[faces[i][10]] == 0     && occupied[faces[i][11]] == 0) {
  1175.                   pos = faces[i][8];
  1176.                   occupied[pos] = MACHINE;
  1177.                   positions.set(pos, MACHINE);
  1178.                   player = update_logic_arrays(pos);
  1179.                   if (debug) System.out.println("block_chair_move: found");
  1180.                   return true;
  1181.                }
  1182.                if (occupied[faces[i][13]] == HUMAN && occupied[faces[i][ 6]] == 0 &&
  1183.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][10]] == 0 &&
  1184.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0) {
  1185.                   pos = faces[i][11];
  1186.                   occupied[pos] = MACHINE;
  1187.                   positions.set(pos, MACHINE);
  1188.                   player = update_logic_arrays(pos);
  1189.                   if (debug) System.out.println("block_chair_move: found");
  1190.                   return true;
  1191.                }
  1192.                if (occupied[faces[i][15]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1193.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 7]] == 0 &&
  1194.                    occupied[faces[i][ 8]] == 0     && occupied[faces[i][11]] == 0) {
  1195.                   pos = faces[i][11];
  1196.                   occupied[pos] = MACHINE;
  1197.                   positions.set(pos, MACHINE);
  1198.                   player = update_logic_arrays(pos);
  1199.                   if (debug) System.out.println("block_chair_move: found");
  1200.                   return true;
  1201.                }
  1202.                if (occupied[faces[i][16]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1203.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 8]] == 0 &&
  1204.                    occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0) {
  1205.                   pos = faces[i][8];
  1206.                   occupied[pos] = MACHINE;
  1207.                   positions.set(pos, MACHINE);
  1208.                   player = update_logic_arrays(pos);
  1209.                   if (debug) System.out.println("block_chair_move: found");
  1210.                   return true;
  1211.                }
  1212.                if (occupied[faces[i][12]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1213.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 8]] == 0 &&
  1214.                    occupied[faces[i][11]] == 0     && occupied[faces[i][16]] == 0) {
  1215.                   pos = faces[i][8];
  1216.                   occupied[pos] = MACHINE;
  1217.                   positions.set(pos, MACHINE);
  1218.                   player = update_logic_arrays(pos);
  1219.                   if (debug) System.out.println("block_chair_move: found");
  1220.                   return true;
  1221.                }
  1222.                if (occupied[faces[i][ 7]] == HUMAN && occupied[faces[i][ 3]] == 0 &&
  1223.                    occupied[faces[i][ 4]] == 0     && occupied[faces[i][ 8]] == 0 &&
  1224.                    occupied[faces[i][11]] == 0     && occupied[faces[i][15]] == 0) {
  1225.                   pos = faces[i][11];
  1226.                   occupied[pos] = MACHINE;
  1227.                   positions.set(pos, MACHINE);
  1228.                   player = update_logic_arrays(pos);
  1229.                   if (debug) System.out.println("block_chair_move: found");
  1230.                   return true;
  1231.                }
  1232.             }
  1233.          }
  1234.          ncorners = 0;
  1235.          corner   = -1;
  1236.       }
  1237.       if (debug) System.out.println("block_chair_move: false");
  1238.       return false;
  1239.    }
  1240.  
  1241.    public boolean block_walk_move() {
  1242.  
  1243.       int pos;
  1244.  
  1245.       if (debug) System.out.println("inside block_walk_move");
  1246.  
  1247.       // Loop through all of the faces.
  1248.       for(int i=0; i<18; i++) {
  1249.  
  1250.          // Look for a matching pattern.
  1251.          if (occupied[faces[i][ 2]] == HUMAN && occupied[faces[i][14]] == HUMAN &&
  1252.              occupied[faces[i][ 3]] == HUMAN && occupied[faces[i][15]] == HUMAN &&
  1253.              occupied[faces[i][ 6]] == 0     && occupied[faces[i][10]] == 0     &&
  1254.              occupied[faces[i][ 7]] == 0     && occupied[faces[i][11]] == 0) {
  1255.  
  1256.             if (occupied[faces[i][ 8]] == HUMAN && occupied[faces[i][ 9]] == 0) {
  1257.                pos = faces[i][6];
  1258.                occupied[pos] = MACHINE;
  1259.                positions.set(pos, MACHINE);
  1260.                player = update_logic_arrays(pos);
  1261.                return true;
  1262.             }
  1263.             else if (occupied[faces[i][12]] == HUMAN && occupied[faces[i][13]] == 0) {
  1264.                pos = faces[i][10];
  1265.                occupied[pos] = MACHINE;
  1266.                positions.set(pos, MACHINE);
  1267.                player = update_logic_arrays(pos);
  1268.                return true;
  1269.             }
  1270.          }
  1271.  
  1272.          // Look for a matching pattern.
  1273.          if (occupied[faces[i][14]] == HUMAN && occupied[faces[i][17]] == HUMAN &&
  1274.              occupied[faces[i][10]] == HUMAN && occupied[faces[i][13]] == HUMAN &&
  1275.              occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0     &&
  1276.              occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0) {
  1277.  
  1278.             if (occupied[faces[i][7]] == HUMAN && occupied[faces[i][3]] == 0) {
  1279.                pos = faces[i][15];
  1280.                occupied[pos] = MACHINE;
  1281.                positions.set(pos, MACHINE);
  1282.                player = update_logic_arrays(pos);
  1283.                return true;
  1284.             }
  1285.             else if (occupied[faces[i][8]] == HUMAN && occupied[faces[i][4]] == 0) {
  1286.                pos = faces[i][16];
  1287.                occupied[pos] = MACHINE;
  1288.                positions.set(pos, MACHINE);
  1289.                player = update_logic_arrays(pos);
  1290.                return true;
  1291.             }
  1292.          }
  1293.  
  1294.          // Look for a matching pattern.
  1295.          if (occupied[faces[i][ 4]] == HUMAN && occupied[faces[i][16]] == HUMAN &&
  1296.              occupied[faces[i][ 5]] == HUMAN && occupied[faces[i][17]] == HUMAN &&
  1297.              occupied[faces[i][ 8]] == 0     && occupied[faces[i][12]] == 0     &&
  1298.              occupied[faces[i][ 9]] == 0     && occupied[faces[i][13]] == 0) {
  1299.  
  1300.             if (occupied[faces[i][11]] == HUMAN && occupied[faces[i][10]] == 0) {
  1301.                pos = faces[i][18];
  1302.                occupied[pos] = MACHINE;
  1303.                positions.set(pos, MACHINE);
  1304.                player = update_logic_arrays(pos);
  1305.                return true;
  1306.             }
  1307.             else if (occupied[faces[i][7]] == HUMAN && occupied[faces[i][6]] == 0) {
  1308.                pos = faces[i][9];
  1309.                occupied[pos] = MACHINE;
  1310.                positions.set(pos, MACHINE);
  1311.                player = update_logic_arrays(pos);
  1312.                return true;
  1313.             }
  1314.          }
  1315.  
  1316.          // Look for a matching pattern.
  1317.          if (occupied[faces[i][ 6]] == HUMAN && occupied[faces[i][ 9]] == HUMAN &&
  1318.              occupied[faces[i][ 2]] == HUMAN && occupied[faces[i][ 5]] == HUMAN &&
  1319.              occupied[faces[i][ 7]] == 0     && occupied[faces[i][ 8]] == 0     &&
  1320.              occupied[faces[i][ 3]] == 0     && occupied[faces[i][ 4]] == 0) {
  1321.  
  1322.             if (occupied[faces[i][11]] == HUMAN && occupied[faces[i][15]] == 0) {
  1323.                pos = faces[i][3];
  1324.                occupied[pos] = MACHINE;
  1325.                positions.set(pos, MACHINE);
  1326.                player = update_logic_arrays(pos);
  1327.                return true;
  1328.             }
  1329.             else if (occupied[faces[i][12]] == HUMAN && occupied[faces[i][16]] == 0) {
  1330.                pos = faces[i][4];
  1331.                occupied[pos] = MACHINE;
  1332.                positions.set(pos, MACHINE);
  1333.                player = update_logic_arrays(pos);
  1334.                return true;
  1335.             }
  1336.          }
  1337.  
  1338.          // Look for a matching pattern.
  1339.          if (occupied[faces[i][ 2]] == HUMAN && occupied[faces[i][14]] == HUMAN &&
  1340.              occupied[faces[i][ 4]] == HUMAN && occupied[faces[i][16]] == HUMAN &&
  1341.              occupied[faces[i][ 6]] == 0     && occupied[faces[i][10]] == 0     &&
  1342.              occupied[faces[i][ 8]] == 0     && occupied[faces[i][12]] == 0) {
  1343.  
  1344.             if ((occupied[faces[i][7]] == HUMAN && occupied[faces[i][9]] == 0) ||
  1345.                 (occupied[faces[i][9]] == HUMAN && occupied[faces[i][7]] == 0)   ) {
  1346.                pos = faces[i][6];
  1347.                occupied[pos] = MACHINE;
  1348.                positions.set(pos, MACHINE);
  1349.                player = update_logic_arrays(pos);
  1350.                return true;
  1351.             }
  1352.             else if ((occupied[faces[i][11]] == HUMAN && occupied[faces[i][13]] == 0) ||
  1353.                      (occupied[faces[i][13]] == HUMAN && occupied[faces[i][11]] == 0)   ) {
  1354.                pos = faces[i][10];
  1355.                occupied[pos] = MACHINE;
  1356.                positions.set(pos, MACHINE);
  1357.                player = update_logic_arrays(pos);
  1358.                return true;
  1359.             }
  1360.          }
  1361.  
  1362.          // Look for a matching pattern.
  1363.          if (occupied[faces[i][14]] == HUMAN && occupied[faces[i][17]] == HUMAN &&
  1364.              occupied[faces[i][ 6]] == HUMAN && occupied[faces[i][ 9]] == HUMAN &&
  1365.              occupied[faces[i][15]] == 0     && occupied[faces[i][16]] == 0     &&
  1366.              occupied[faces[i][ 7]] == 0     && occupied[faces[i][ 8]] == 0) {
  1367.  
  1368.             if ((occupied[faces[i][11]] == HUMAN && occupied[faces[i][ 3]] == 0) ||
  1369.                 (occupied[faces[i][ 3]] == HUMAN && occupied[faces[i][11]] == 0)   ) {
  1370.                pos = faces[i][15];
  1371.                occupied[pos] = MACHINE;
  1372.                positions.set(pos, MACHINE);
  1373.                player = update_logic_arrays(pos);
  1374.                return true;
  1375.             }
  1376.             else if ((occupied[faces[i][12]] == HUMAN && occupied[faces[i][ 4]] == 0) ||
  1377.                      (occupied[faces[i][ 4]] == HUMAN && occupied[faces[i][12]] == 0)   ) {
  1378.                pos = faces[i][16];
  1379.                occupied[pos] = MACHINE;
  1380.                positions.set(pos, MACHINE);
  1381.                player = update_logic_arrays(pos);
  1382.                return true;
  1383.             }
  1384.          }
  1385.  
  1386.          // Look for a matching pattern.
  1387.          if (occupied[faces[i][ 3]] == HUMAN && occupied[faces[i][15]] == HUMAN &&
  1388.              occupied[faces[i][ 5]] == HUMAN && occupied[faces[i][17]] == HUMAN &&
  1389.              occupied[faces[i][ 7]] == 0     && occupied[faces[i][11]] == 0     &&
  1390.              occupied[faces[i][ 9]] == 0     && occupied[faces[i][13]] == 0) {
  1391.  
  1392.             if ((occupied[faces[i][ 6]] == HUMAN && occupied[faces[i][ 8]] == 0) ||
  1393.                 (occupied[faces[i][ 8]] == HUMAN && occupied[faces[i][ 6]] == 0)   ) {
  1394.                pos = faces[i][9];
  1395.                occupied[pos] = MACHINE;
  1396.                positions.set(pos, MACHINE);
  1397.                player = update_logic_arrays(pos);
  1398.                return true;
  1399.             }
  1400.             else if ((occupied[faces[i][10]] == HUMAN && occupied[faces[i][12]] == 0) ||
  1401.                      (occupied[faces[i][12]] == HUMAN && occupied[faces[i][10]] == 0)   ) {
  1402.                pos = faces[i][13];
  1403.                occupied[pos] = MACHINE;
  1404.                positions.set(pos, MACHINE);
  1405.                player = update_logic_arrays(pos);
  1406.                return true;
  1407.             }
  1408.          }
  1409.  
  1410.          // Look for a matching pattern.
  1411.          if (occupied[faces[i][10]] == HUMAN && occupied[faces[i][13]] == HUMAN &&
  1412.              occupied[faces[i][ 2]] == HUMAN && occupied[faces[i][ 5]] == HUMAN &&
  1413.              occupied[faces[i][11]] == 0     && occupied[faces[i][12]] == 0     &&
  1414.              occupied[faces[i][ 3]] == 0     && occupied[faces[i][ 4]] == 0) {
  1415.  
  1416.             if ((occupied[faces[i][ 7]] == HUMAN && occupied[faces[i][15]] == 0) ||
  1417.                 (occupied[faces[i][15]] == HUMAN && occupied[faces[i][ 7]] == 0)   ) {
  1418.                pos = faces[i][3];
  1419.                occupied[pos] = MACHINE;
  1420.                positions.set(pos, MACHINE);
  1421.                player = update_logic_arrays(pos);
  1422.                return true;
  1423.             }
  1424.             else if ((occupied[faces[i][ 8]] == HUMAN && occupied[faces[i][16]] == 0) ||
  1425.                      (occupied[faces[i][16]] == HUMAN && occupied[faces[i][ 8]] == 0)   ) {
  1426.                pos = faces[i][4];
  1427.                occupied[pos] = MACHINE;
  1428.                positions.set(pos, MACHINE);
  1429.                player = update_logic_arrays(pos);
  1430.                return true;
  1431.             }
  1432.          }
  1433.  
  1434.       }
  1435.  
  1436.       if (debug) System.out.println("block_walk_move: false");
  1437.       return false;
  1438.    }
  1439.  
  1440.    public boolean check_chair_move() {
  1441.  
  1442.       int pos;
  1443.  
  1444.       // If the "block chair flag" is set, all we need to do is
  1445.       // block the winning path...
  1446.       if (block_chair_flag) {
  1447.          pos = faces[block_chair_face][block_chair_next_move];
  1448.          occupied[pos] = MACHINE;
  1449.          positions.set(pos, MACHINE);
  1450.          player = update_logic_arrays(pos);
  1451.          if (debug) System.out.println("block_chair_move: march");
  1452.          return true;
  1453.       }
  1454.  
  1455.       int ncorners = 0;    // Number of corners owned by human
  1456.       int corner   = 0;    // Corner owned by machine
  1457.  
  1458.       // Loop through all of the faces.
  1459.       for(int i=0; i<18; i++) {
  1460.  
  1461.          // Determine which corners the human owns.
  1462.          if (faces[i][ 2] == HUMAN)
  1463.             ncorners++;   
  1464.          else
  1465.             corner = 2;
  1466.          if (faces[i][ 5] == HUMAN) 
  1467.             ncorners++;   
  1468.          else
  1469.             corner = 5;
  1470.          if (faces[i][14] == HUMAN)
  1471.             ncorners++;   
  1472.          else
  1473.             corner = 14;
  1474.          if (faces[i][17] == HUMAN)
  1475.             ncorners++;   
  1476.          else
  1477.             corner = 17;
  1478.  
  1479.          // If the human owns three corners, continue with the search.
  1480.          if (ncorners == 3) {
  1481.             if (corner == 2) {
  1482.                if (faces[i][ 3] == HUMAN && faces[i][ 7] == 0 &&
  1483.                    faces[i][ 8] == 0     && faces[i][11] == 0 &&
  1484.                    faces[i][15] == 0     && faces[i][16] == 0) {
  1485.                   block_chair_flag = true;
  1486.                   block_chair_next_move = 11;
  1487.                   block_chair_face = i;
  1488.                   pos = faces[i][15];
  1489.                   occupied[pos] = MACHINE;
  1490.                   positions.set(pos, MACHINE);
  1491.                   player = update_logic_arrays(pos);
  1492.                   if (debug) System.out.println("block_chair_move: found");
  1493.                   return true;
  1494.                }
  1495.                if (faces[i][ 4] == HUMAN && faces[i][ 8] == 0 &&
  1496.                    faces[i][11] == 0     && faces[i][12] == 0 &&
  1497.                    faces[i][15] == 0     && faces[i][16] == 0) {
  1498.                   block_chair_flag = true;
  1499.                   block_chair_next_move = 16;
  1500.                   block_chair_face = i;
  1501.                   pos = faces[i][8];
  1502.                   occupied[pos] = MACHINE;
  1503.                   positions.set(pos, MACHINE);
  1504.                   player = update_logic_arrays(pos);
  1505.                   if (debug) System.out.println("block_chair_move: found");
  1506.                   return true;
  1507.                }
  1508.             }
  1509.             else if (corner == 5) {
  1510.                   block_chair_flag = true;
  1511.                   block_chair_next_move = 11;
  1512.                   block_chair_face = i;
  1513.                   pos = faces[i][15];
  1514.                   occupied[pos] = MACHINE;
  1515.                   positions.set(pos, MACHINE);
  1516.                   player = update_logic_arrays(pos);
  1517.                   if (debug) System.out.println("check_face_three:  true");
  1518.                   return true;
  1519.             }
  1520.             else if (corner == 14) {
  1521.                   block_chair_flag = true;
  1522.                   block_chair_next_move = 11;
  1523.                   block_chair_face = i;
  1524.                   pos = faces[i][15];
  1525.                   occupied[pos] = MACHINE;
  1526.                   positions.set(pos, MACHINE);
  1527.                   player = update_logic_arrays(pos);
  1528.                   if (debug) System.out.println("check_face_three:  true");
  1529.                   return true;
  1530.             }
  1531.             else if (corner == 17) {
  1532.                   block_chair_flag = true;
  1533.                   block_chair_next_move = 11;
  1534.                   block_chair_face = i;
  1535.                   pos = faces[i][15];
  1536.                   occupied[pos] = MACHINE;
  1537.                   positions.set(pos, MACHINE);
  1538.                   player = update_logic_arrays(pos);
  1539.                   if (debug) System.out.println("check_face_three:  true");
  1540.                   return true;
  1541.             }
  1542.          }
  1543.       }
  1544.       return false;
  1545.    }
  1546.  
  1547.    /**
  1548.     *  Take inside four
  1549.     */
  1550.    public boolean take_inside_four() {
  1551.  
  1552.       int pos = 0;
  1553.       boolean found = false;
  1554.  
  1555.       if (occupied[21] == 0) {
  1556.          found = true;
  1557.          pos = 21;
  1558.       }
  1559.       else if (occupied[22] == 0) {
  1560.          found = true;
  1561.          pos = 22;
  1562.       }
  1563.       else if (occupied[25] == 0) {
  1564.          found = true;
  1565.          pos = 25;
  1566.       }
  1567.       else if (occupied[26] == 0) {
  1568.          found = true;
  1569.          pos = 26;
  1570.       }
  1571.       else if (occupied[37] == 0) {
  1572.          found = true;
  1573.          pos = 37;
  1574.       }
  1575.       else if (occupied[38] == 0) {
  1576.          found = true;
  1577.          pos = 38;
  1578.       }
  1579.       else if (occupied[41] == 0) {
  1580.          found = true;
  1581.          pos = 41;
  1582.       }
  1583.       else if (occupied[42] == 0) {
  1584.          found = true;
  1585.          pos = 42;
  1586.       }
  1587.  
  1588.       if (found) {
  1589.          occupied[pos] = MACHINE;
  1590.          positions.set(pos, MACHINE);
  1591.          player = update_logic_arrays(pos);
  1592.          if (debug) System.out.println("take_inside_four:  true");
  1593.          return true;
  1594.       }
  1595.  
  1596.       if (debug) System.out.println("take_inside_four:  false");
  1597.       return false;
  1598.    }
  1599.  
  1600.  
  1601.    /**
  1602.     *  Check occupancy of outside four.
  1603.     */
  1604.    public boolean check_outside_four() {
  1605.  
  1606.       int pos = 0;
  1607.  
  1608.       // Finish off the four corner combination.
  1609.       if (outside_four_flag) {
  1610.          if (occupied[faces[face_index][7]] == 0) {
  1611.             pos = faces[face_index][7];
  1612.          }
  1613.          else if (occupied[faces[face_index][6]] == 0) {
  1614.             pos = faces[face_index][6];
  1615.          }
  1616.        
  1617.          if (occupied[pos] == 0) {
  1618.             occupied[pos] = MACHINE;
  1619.             positions.set(pos, MACHINE);
  1620.             player = update_logic_arrays(pos);
  1621.             return true;  
  1622.          }
  1623.       }
  1624.  
  1625.       // Look for a four corner combination.
  1626.       for (int i=0; i<18; i++) {
  1627.          if (outside_four[i][0] == 4 &&
  1628.              outside_four[i][1] == MACHINE) {
  1629.             if (faces[i][0] > 0 &&
  1630.                 faces[i][1] == MACHINE) {
  1631.                if (occupied[faces[i][8]] == 0) {
  1632.                   pos = faces[i][8];
  1633.                   outside_four_flag = true;
  1634.                   face_index = i; 
  1635.                }
  1636.                if (occupied[pos] == 0) {
  1637.                   occupied[pos] = MACHINE;
  1638.                   positions.set(pos, MACHINE);
  1639.                   player = update_logic_arrays(pos);
  1640.                   if (debug) System.out.println("check_outside_four:  true");
  1641.                   return true;  
  1642.                }
  1643.             }
  1644.          }
  1645.       }
  1646.  
  1647.       // Take the corners, if available.
  1648.       for (int i=0; i<18; i++) {
  1649.          if (outside_four[i][0] > 0 &&
  1650.              outside_four[i][1] == MACHINE) {
  1651.             if (faces[i][0] > 0 &&
  1652.                 faces[i][1] == MACHINE) {
  1653.                for (int j=2; j<6; j++) {
  1654.                   pos = outside_four[i][j];
  1655.                   if (occupied[pos] == 0) {
  1656.                      occupied[pos] = MACHINE;
  1657.                      positions.set(pos, MACHINE);
  1658.                      player = update_logic_arrays(pos);
  1659.                      if (debug) System.out.println("check_outside_four:  true");
  1660.                      return true;  
  1661.                   }
  1662.                }
  1663.             }
  1664.          }
  1665.       }
  1666.  
  1667.       // Look for an "outside four" combination in a face in which the 
  1668.       // opponent holds no positions.
  1669.       for (int i=0; i<18; i++) {
  1670.          if (outside_four[i][0] == 0 || (outside_four[i][0] > 0 &&
  1671.              outside_four[i][1] == MACHINE)) {
  1672.  
  1673.             if (outside_four[i][1] == MACHINE)
  1674.                 outside_four_flag = true;
  1675.             for (int j=2; j<6; j++) {
  1676.                pos = outside_four[i][j];
  1677.                if (occupied[pos] == 0) {
  1678.                   occupied[pos] = MACHINE;
  1679.                   positions.set(pos, MACHINE);
  1680.                   player = update_logic_arrays(pos);
  1681.                   if (debug) System.out.println("check_outside_four:  true");
  1682.                   return true;  
  1683.                }
  1684.             }
  1685.          }
  1686.       }
  1687.  
  1688.       if (debug) System.out.println("check_outside_four:  false");
  1689.       return false;
  1690.    }
  1691.  
  1692.  
  1693.    /**
  1694.     *  Take outside four
  1695.     */
  1696.    public boolean take_outside_four() {
  1697.  
  1698.       int pos = 0;
  1699.       boolean found = false; 
  1700.  
  1701.       if (occupied[0] == 0) {
  1702.          found = true; 
  1703.          pos = 0; 
  1704.       }  
  1705.       else if (occupied[3] == 0) {
  1706.          found = true;   
  1707.          pos = 3;   
  1708.       }  
  1709.       else if (occupied[12] == 0) {
  1710.          found = true;   
  1711.          pos = 12;   
  1712.       }  
  1713.       else if (occupied[15] == 0) {
  1714.          found = true;   
  1715.          pos = 15;   
  1716.       }  
  1717.       else if (occupied[48] == 0) {
  1718.          found = true;   
  1719.          pos = 48;  
  1720.       }  
  1721.       else if (occupied[51] == 0) {
  1722.          found = true;   
  1723.          pos = 51;   
  1724.       }  
  1725.       else if (occupied[60] == 0) {
  1726.          found = true;   
  1727.          pos = 60;   
  1728.       }  
  1729.       else if (occupied[63] == 0) {
  1730.          found = true;   
  1731.          pos = 63;
  1732.       }  
  1733.   
  1734.       if (found) { 
  1735.          occupied[pos] = MACHINE;
  1736.          positions.set(pos, MACHINE);
  1737.          player = update_logic_arrays(pos);
  1738.          if (debug) System.out.println("take_outside_four:  true");
  1739.          return true;
  1740.       }
  1741.  
  1742.       if (debug) System.out.println("take_outside_four:  false");
  1743.       return false;
  1744.    }
  1745.  
  1746.  
  1747.    /**
  1748.     *  Check for a forced win by intersecting rows. Block
  1749.     *  if necessary.
  1750.     */
  1751.    public boolean block_intersecting_rows() {
  1752.  
  1753.       int pos;
  1754.  
  1755.       // Loop through each row and check for rows that have two
  1756.       // positions occupied by the human and two positions which are empty.
  1757.       // Make sure that none of the empty positions in this row intersect 
  1758.       // with another row that also contains two positions held by the human. 
  1759.       // If so, block the row by taking the position at the intersection
  1760.       // of these two row.
  1761.  
  1762.       // Loop through each row.
  1763.       for (int i=0; i<76; i++) {
  1764.  
  1765.          // Look for a row that has two positions held by the human. 
  1766.          if (combinations[i][0] == 2  && combinations[i][1] == HUMAN) {
  1767.  
  1768.             if (debug)
  1769.                System.out.println("   row " + i + "has 2 positions occupied by the human");
  1770.  
  1771.             // Mark this row with a flag.
  1772.             combinations[i][6] = 1;
  1773.  
  1774.             // Check each position in the row.
  1775.             for (int j=2; j<6; j++) {
  1776.  
  1777.                // Look for the empty positions in the row.
  1778.                pos = combinations[i][j];
  1779.                if (occupied[pos] == 0) {
  1780.  
  1781.                   // Loop through the rows again.
  1782.                   for (int k=0; k<76; k++) {
  1783.  
  1784.                      if (debug) System.out.println("   row " + k);
  1785.  
  1786.                      // Look for another row that has two positions held
  1787.                      // by the human (and which is unmarked.) modified
  1788.                      if (combinations[k][0] == 2     &&
  1789.                          combinations[k][1] == HUMAN &&
  1790.                          combinations[k][6] == 0)       {
  1791.  
  1792.                         if (debug)
  1793.                            System.out.println("found an intersecting row:   row " + k);
  1794.  
  1795.                         // Check the positions in this row and see if
  1796.                         // any match the position we're looking for. If
  1797.                         // we find a match, grab the position and return.
  1798.                         for (int l=2; l<6; l++) {
  1799.                            if (pos == combinations[k][l]) {
  1800.                               combinations[i][6] = 0;
  1801.                               occupied[pos] = MACHINE;
  1802.                               positions.set(pos, MACHINE);
  1803.                               player = update_logic_arrays(pos);
  1804.                               if (debug) System.out.println("block_intersecting_rows:  true");
  1805.                               return true;
  1806.                            }
  1807.                         }
  1808.                      }
  1809.                   }
  1810.                }
  1811.             }
  1812.  
  1813.             // Unmark the combination before moving on.
  1814.             combinations[i][6] = 0;
  1815.          }
  1816.  
  1817.       }
  1818.       if (debug) System.out.println("block_intersecting_rows:  false");
  1819.       return false;
  1820.    }
  1821.  
  1822.    /**
  1823.     *  Check for a forced win by intersecting rows. Block
  1824.     *  if necessary.
  1825.     */
  1826.    public boolean check_intersecting_rows2() {
  1827.  
  1828.       int pos;
  1829.  
  1830.       // Loop through each row and check for rows that have two
  1831.       // positions occupied by the human and two positions which are empty.
  1832.       // Make sure that none of the empty positions in this row intersect 
  1833.       // with another row that also contains two positions held by the human. 
  1834.       // If so, block the row by taking the position at the intersection
  1835.       // of these two row.
  1836.  
  1837.       // Loop through each row.
  1838.       for (int i=0; i<76; i++) {
  1839.  
  1840.          // Look for a row that has two positions held by the human. 
  1841.          if (combinations[i][0] == 2  && combinations[i][1] == HUMAN) {
  1842.  
  1843.             if (debug) {
  1844.                System.out.println("   row " + i + "has 2 positions occupied by the human");
  1845.             }
  1846.  
  1847.             // Mark this row with a flag.
  1848.             combinations[i][6] = 1;
  1849.  
  1850.             // Check each position in the row.
  1851.             for (int j=2; j<6; j++) {
  1852.  
  1853.                // Look for the empty positions in the row.
  1854.                pos = combinations[i][j];
  1855.                if (occupied[pos] == 0) {
  1856.  
  1857.                   // Loop through the rows again.
  1858.                   for (int k=0; k<76; k++) {
  1859.  
  1860.                      if (debug) System.out.println("   row " + k);
  1861.  
  1862.                      // Look for another row that has two positions held
  1863.                      // by the human (and which is unmarked.) modified
  1864.                      if (combinations[k][0] == 1     &&
  1865.                          combinations[k][1] == HUMAN &&
  1866.                          combinations[k][6] == 0)       {
  1867.  
  1868.                         if (debug)
  1869.                            System.out.println("found an intersecting row:   row " + k);
  1870.  
  1871.                         // Check the positions in this row and see if
  1872.                         // any match the position we're looking for. If
  1873.                         // we find a match, grab the position and return.
  1874.                         for (int l=2; l<6; l++) {
  1875.                            if (pos == combinations[k][l]) {
  1876.                               combinations[i][6] = 0;
  1877.                               occupied[pos] = MACHINE;
  1878.                               positions.set(pos, MACHINE);
  1879.                               player = update_logic_arrays(pos);
  1880.                               if (debug) System.out.println("check_intersecting_rows:  true");
  1881.                               return true;
  1882.                            }
  1883.                         }
  1884.                      }
  1885.                   }
  1886.                }
  1887.             }
  1888.  
  1889.             // Unmark the combination before moving on.
  1890.             combinations[i][6] = 0;
  1891.          }
  1892.  
  1893.       }
  1894.       if (debug) System.out.println("check_intersecting_rows:  false");
  1895.       return false;
  1896.    }
  1897.  
  1898.  
  1899.    /**
  1900.     *  Check for a forced win by intersecting rows. Block
  1901.     *  if necessary.
  1902.     */
  1903.    public boolean check_for_two() {
  1904.  
  1905.       int pos;
  1906.  
  1907.       // Loop through the rows.
  1908.       for (int i=0; i<76; i++) {
  1909.  
  1910.          // Look for a row that has two positions held
  1911.          // by the human (and which is unmarked.)
  1912.          if (combinations[i][0] == 2     &&  
  1913.              combinations[i][1] == HUMAN &&
  1914.              combinations[i][6] == 0)       {
  1915.  
  1916.             // Take the first available spot.
  1917.             for (int j=2; j<6; j++) {
  1918.                pos = combinations[i][j];
  1919.                if (occupied[pos] == 0) {
  1920.                   occupied[pos] = MACHINE;
  1921.                   positions.set(pos, MACHINE);
  1922.                   player = update_logic_arrays(pos);
  1923.                   if (debug) System.out.println("check_for_two:  true");
  1924.                   return true;  
  1925.                }
  1926.             }   
  1927.  
  1928.          }   
  1929.       }   
  1930.       if (debug) System.out.println("check_for_two:  false");
  1931.       return false;
  1932.    }
  1933.  
  1934.    public void undo_move() {
  1935.  
  1936.       // Return if no moves are recorded
  1937.       if (nmoves == 0) return;
  1938.  
  1939.       // Set the undo flag
  1940.       undoFlag = true;
  1941.  
  1942.       // Undo the last two moves
  1943.       positions.clear(moves[--nmoves]);
  1944.       positions.clear(moves[--nmoves]);
  1945.  
  1946.       // Undo the winner flag in the positions object
  1947.       positions.noWinner();
  1948.  
  1949.       // Repaint the 2D canvas.
  1950.       canvas.repaint();
  1951.  
  1952.       // Reset the inside/outside flags
  1953.       inside_four_flag = false;
  1954.       outside_four_flag = false;
  1955.       block_chair_flag = false;
  1956.  
  1957.       // Reset the board
  1958.       for (int i=0; i<64; i++) {
  1959.          occupied[i] = 0;
  1960.       }
  1961.  
  1962.       // Reset the inside/outside arrays
  1963.       for (int i=0; i<18; i++) {
  1964.           inside_four[i][0] = 0;
  1965.           inside_four[i][1] = 0;
  1966.           outside_four[i][0] = 0;
  1967.           outside_four[i][1] = 0;
  1968.       }
  1969.  
  1970.       // Reset the faces array
  1971.       for (int i=0; i<18; i++) {
  1972.           faces[i][0] = 0;
  1973.           faces[i][1] = 0;
  1974.       }
  1975.  
  1976.       // Reset the combinations array
  1977.       for (int i=0; i<76; i++) {
  1978.          combinations[i][0] = 0;
  1979.          combinations[i][1] = 0;
  1980.       }
  1981.  
  1982.       if (nmoves == 0) {
  1983.          undoFlag = false;
  1984.          player = HUMAN;
  1985.          return;
  1986.       }
  1987.  
  1988.       // Update the logic arrays
  1989.       int pos;
  1990.       player = HUMAN;
  1991.       for (int i=0; i<nmoves; i++) {
  1992.          pos = moves[i]; 
  1993.          occupied[pos] = player;
  1994.          player = update_logic_arrays(pos);
  1995.       }
  1996.  
  1997.       // Reset the "best picks" array
  1998.       update_best_picks();
  1999.  
  2000.       // Reset the player and undo flag
  2001.       player = HUMAN;
  2002.       undoFlag = false;
  2003.    }
  2004.  
  2005.    /**
  2006.     *  Update the logic arrays that keep track of positions and status.
  2007.     *  If we have a winner, stop the game.
  2008.     */
  2009.    public int update_logic_arrays(int pos) {
  2010.  
  2011.       // Record the move.
  2012.       if (!undoFlag) {
  2013.          moves[nmoves++] = pos;
  2014.       }
  2015.  
  2016.       // Get the number of combinations that this position has.
  2017.       int num_combinations = pos_to_comb[pos][0];
  2018.  
  2019.       // Go through each combination associated with this position 
  2020.       // and update the status. If we have a winner, stop the game.
  2021.       int comb;
  2022.       for (int j=0; j<num_combinations; j++) {
  2023.          comb = pos_to_comb[pos][j+1];
  2024.          if (combinations[comb][1] != player &&
  2025.              combinations[comb][1] != 0) {
  2026.             combinations[comb][0] = -1;
  2027.          }
  2028.          else {
  2029.             combinations[comb][0]++;
  2030.             if (combinations[comb][0] == 4) {
  2031.                end_time = System.currentTimeMillis();
  2032.                time = (end_time - beg_time)/1000;
  2033.                panel.winner(player, skill_level, nmoves, time);
  2034.                panel.repaint();
  2035.                canvas.repaint();
  2036.                positions.winner();
  2037.                return END;
  2038.             }
  2039.             else {
  2040.                combinations[comb][1] = player;
  2041.             }
  2042.          }      
  2043.       }  
  2044.  
  2045.       // Update the best_picks array.
  2046.       update_best_picks();
  2047.  
  2048.       // Update the inside_four array.
  2049.       for (int i=0; i<18; i++) {
  2050.          for (int j=2; j<6; j++) {
  2051.             if (pos == inside_four[i][j]) {
  2052.                 if (inside_four[i][0] == 0) {
  2053.                    inside_four[i][0] = 1;
  2054.                    inside_four[i][1] = player;
  2055.                 }
  2056.                 else if (inside_four[i][1] == player) {
  2057.                    inside_four[i][0]++;
  2058.                    inside_four[i][1] = player;
  2059.                 }
  2060.                 else {
  2061.                    inside_four[i][0] = -1;
  2062.                 }
  2063.             }
  2064.          }
  2065.       }
  2066.  
  2067.       // Update the outside_four array.
  2068.       for (int i=0; i<18; i++) {
  2069.          for (int j=2; j<6; j++) {
  2070.             if (pos == outside_four[i][j]) {
  2071.                if (outside_four[i][0] == 0) {
  2072.                   outside_four[i][0] = 1;
  2073.                   outside_four[i][1] = player;
  2074.                }
  2075.                else if (outside_four[i][1] == player) {
  2076.                   outside_four[i][0]++;
  2077.                   outside_four[i][1] = player;
  2078.                }
  2079.                else {
  2080.                   outside_four[i][0] = -1;
  2081.                }
  2082.             }
  2083.          }
  2084.       }
  2085.       
  2086.       // Update the faces array.
  2087.       for (int i=0; i<18; i++) {
  2088.          for (int j=2; j<18; j++) {
  2089.             if (pos == faces[i][j]) {
  2090.                if (faces[i][0] == 0) {
  2091.                   faces[i][0] = 1;
  2092.                   faces[i][1] = player;
  2093.                }
  2094.                else if (faces[i][1] == player) {
  2095.                   faces[i][0]++;
  2096.                }
  2097.                else {
  2098.                   faces[i][0] = -1;
  2099.                }
  2100.             }
  2101.          }
  2102.           
  2103.       }
  2104.  
  2105.       // Switch players.
  2106.       if (player == HUMAN)
  2107.          return MACHINE;
  2108.       else
  2109.          return HUMAN;
  2110.    }
  2111.  
  2112.  
  2113.    /**
  2114.     *  Start a new game.
  2115.     */
  2116.    public void newGame() {
  2117.  
  2118.       // Initialize the inside/outside flags.
  2119.       inside_four_flag = false;
  2120.       outside_four_flag = false;
  2121.       block_chair_flag = false;
  2122.  
  2123.       // Initialize the inside/outside arrays.
  2124.       for (int i=0; i<18; i++) {
  2125.           inside_four[i][0] = 0;
  2126.           inside_four[i][1] = 0;
  2127.           outside_four[i][0] = 0;
  2128.           outside_four[i][1] = 0;
  2129.       }
  2130.  
  2131.       // Initialize the faces array.
  2132.       for (int i=0; i<18; i++) {
  2133.           faces[i][0] = 0;
  2134.           faces[i][1] = 0;
  2135.       }
  2136.  
  2137.       // Initialize the board.
  2138.       for (int i=0; i<64; i++) {
  2139.          occupied[i] = 0;
  2140.       }
  2141.       for (int i=0; i<76; i++) {
  2142.          combinations[i][0] = 0;
  2143.          combinations[i][1] = 0;
  2144.       }
  2145.  
  2146.       // Reset the best_picks array.
  2147.       update_best_picks();
  2148.  
  2149.       // Set the player with the first move.
  2150.       player = HUMAN;
  2151.  
  2152.       // Initialize the number of moves.
  2153.       nmoves = 0;
  2154.  
  2155.       // Reset the playing positions.
  2156.       positions.newGame();
  2157.    }
  2158.  
  2159.  
  2160.    /**
  2161.     *  Set the skill level.
  2162.     */
  2163.    public void set_skill_level(int level) {
  2164.       skill_level = level;
  2165.    }
  2166.  
  2167.  
  2168.    /**
  2169.     *  Set up the pos_to_comb array.
  2170.     */
  2171.    public void setup_pos_to_comb() {
  2172.  
  2173.       // Set up the pos_to_comb array to point to every winning
  2174.       // combination a given position may have.
  2175.       int count;
  2176.       for (int i=0; i<64; i++) {
  2177.           count = 1;
  2178.           pos_to_comb[i][0] = 0;
  2179.           for (int j=0; j<76; j++) {
  2180.                 for (int k=2; k<6; k++) {
  2181.                    if (combinations[j][k] == i) {
  2182.                        pos_to_comb[i][0]++;
  2183.                        pos_to_comb[i][count++] = j;
  2184.                    }
  2185.                 }
  2186.           }
  2187.       }
  2188.  
  2189.       if (debug) {
  2190.          for (int i=0; i<64; i++) {
  2191.              System.out.println("");
  2192.              for (int j=0; j<8; j++) {
  2193.                 System.out.println("pos_to_comb[" + i + "][" + j + "] = " + pos_to_comb[i][j]);
  2194.              }
  2195.          }
  2196.       }
  2197.  
  2198.    }
  2199.  
  2200.  
  2201.    /**
  2202.     *  Update the best_picks array.
  2203.     */
  2204.    public void update_best_picks() {
  2205.  
  2206.       // Re-calculate the best_picks array to point to every (current) winning 
  2207.       // combination a given position may have.
  2208.       int count;
  2209.       for (int i=0; i<64; i++) {
  2210.  
  2211.           count = 1;
  2212.           best_picks[i][0] = 0;
  2213.           if (occupied[i] == 0) {
  2214.              for (int j=0; j<76; j++) {
  2215.  
  2216.                 if (combinations[j][0] == 0 ||
  2217.                     combinations[j][1] == MACHINE) {
  2218.  
  2219.                    for (int k=2; k<6; k++) {
  2220.                       if (combinations[j][k] == i) {
  2221.                          best_picks[i][0]++;
  2222.                          best_picks[i][count++] = j;
  2223.                       }
  2224.                    }
  2225.                 }
  2226.              }
  2227.           }
  2228.       }
  2229.  
  2230.       if (debug) {
  2231.          for (int i=0; i<64; i++) {
  2232.              System.out.println("");
  2233.              for (int j=0; j<8; j++) {
  2234.                 System.out.println("best_picks[" + i + "][" + j + "] = " + best_picks[i][j]); 
  2235.              }
  2236.          }
  2237.       }
  2238.    }
  2239.  
  2240.  
  2241.    /**
  2242.     *  Pick the computer's best possible move based on the number
  2243.     *  of combinations per position. Choose the position with the
  2244.     *  most combinations.
  2245.     */
  2246.    public void pick_best_position() {
  2247.  
  2248.       int pos = 0;
  2249.       int max_num = 0;
  2250.       for (int i=0; i<64; i++) {
  2251.          if (best_picks[i][0] > max_num &&
  2252.              occupied[i] == 0) {
  2253.             pos = i;
  2254.             max_num = best_picks[i][0];
  2255.          }
  2256.       }
  2257.  
  2258.       // Mark the position as MACHINE.
  2259.       occupied[pos] = MACHINE;
  2260.  
  2261.       positions.set(pos, MACHINE);
  2262.  
  2263.       // Udate the logic arrays and reset the player.
  2264.       player = update_logic_arrays(pos);
  2265.    }
  2266.  
  2267.  
  2268.    public boolean pick_7() {
  2269.  
  2270.       for (int i=0; i<64; i++) {
  2271.          if (best_picks[i][0] == 7) { 
  2272.             occupied[i] = MACHINE;
  2273.             positions.set(i, MACHINE);
  2274.             player = update_logic_arrays(i);
  2275.             return true;
  2276.          }
  2277.       }
  2278.       return false;
  2279.  
  2280.    }
  2281.   
  2282.    public void change_face() {
  2283.       current_face = ++current_face%18;
  2284.    }
  2285.   
  2286.    public void label() {
  2287.       label_flag ^= true;
  2288.    }
  2289.  
  2290.    public boolean unoccupied(int pos) {
  2291.       if (occupied[pos] == UNOCCUPIED)
  2292.          return true;
  2293.       else
  2294.          return false;
  2295.    } 
  2296. }
  2297.